synfull 0.0.0-stage → 0.1.0

package/backend/app/config.py

@@ -0,0 +1,51 @@
+from functools import lru_cache
+import os
+from pathlib import Path
+import sys
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+def default_state_dir() -> Path:
+    if sys.platform == "win32":
+        root = Path(os.environ.get("LOCALAPPDATA", Path.home() / "AppData" / "Local"))
+    else:
+        root = Path(os.environ.get("XDG_STATE_HOME", Path.home() / ".local" / "state"))
+    return root / "Synfull" if sys.platform == "win32" else root / "synfull"
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="SYNFULL_", env_file=Path(__file__).resolve().parents[2] / ".env", extra="ignore")
+
+    bind_host: str = "127.0.0.1"
+    bind_port: int = 8000
+    state_dir: Path = Field(default_factory=default_state_dir)
+    database_path: Path | None = None
+    log_dir: Path | None = None
+    collection_interval_seconds: float = 5.0
+    metric_retention_days: int = 30
+    development: bool = False
+    docker_endpoint: str | None = None
+    pm2_executable: str | None = None
+    pm2_owner: str | None = None
+    service_allowlist: str = ""
+    initial_admin_token: str | None = None
+
+    @property
+    def resolved_database_path(self) -> Path:
+        return self.database_path or self.state_dir / "synfull.sqlite3"
+
+    @property
+    def resolved_log_dir(self) -> Path:
+        return self.log_dir or self.state_dir / "logs"
+
+    def prepare_directories(self) -> None:
+        self.state_dir.mkdir(parents=True, exist_ok=True)
+        self.resolved_database_path.parent.mkdir(parents=True, exist_ok=True)
+        self.resolved_log_dir.mkdir(parents=True, exist_ok=True)
+
+
+@lru_cache
+def get_settings() -> Settings:
+    return Settings()

package/backend/app/database.py

@@ -0,0 +1,22 @@
+from sqlalchemy import URL, create_engine
+from sqlalchemy.orm import DeclarativeBase, sessionmaker
+
+from .config import get_settings
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+settings = get_settings()
+settings.prepare_directories()
+engine = create_engine(URL.create("sqlite", database=str(settings.resolved_database_path)), connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(bind=engine, autoflush=False, autocommit=False)
+
+
+def get_db():
+    session = SessionLocal()
+    try:
+        yield session
+    finally:
+        session.close()

package/backend/app/integrations/discord_alerts.py

@@ -0,0 +1,239 @@
+import json
+import logging
+import threading
+import time
+from typing import Any
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlparse
+from urllib.request import Request, urlopen
+
+from sqlalchemy import Boolean, Column, Integer, Text
+
+from ..config import get_settings
+from ..database import Base, SessionLocal, engine
+
+logger = logging.getLogger(__name__)
+
+
+class DiscordAlertConfig(Base):
+    __tablename__ = "discord_alert_config"
+
+    id = Column(Integer, primary_key=True, default=1)
+    webhook_url = Column(Text, nullable=False, default="")
+    enabled = Column(Boolean, nullable=False, default=False)
+    events_json = Column(Text, nullable=False, default='{"start":true,"stop":true,"crash":true,"restart":true}')
+    minimum_interval_seconds = Column(Integer, nullable=False, default=60)
+
+
+Base.metadata.create_all(bind=engine)
+
+DEFAULT_EVENTS = {"start": True, "stop": True, "crash": True, "restart": True}
+EMBED_BLUE = 0x3B82F6
+WEBHOOK_USERNAME = "Synfull - AIO Monitoring Software"
+WEBHOOK_AVATAR_URL = "https://api.iconify.design/lucide/activity.svg?color=%23ffffff"
+
+
+def _config_from_db() -> DiscordAlertConfig:
+    with SessionLocal() as session:
+        config = session.get(DiscordAlertConfig, 1)
+        if config is None:
+            config = DiscordAlertConfig(id=1)
+            session.add(config)
+            session.commit()
+            session.refresh(config)
+        return config
+
+
+def _parse_events(raw: str) -> dict[str, bool]:
+    try:
+        events = json.loads(raw)
+    except (TypeError, json.JSONDecodeError):
+        events = {}
+    return {key: bool(events.get(key, False)) for key in DEFAULT_EVENTS} if isinstance(events, dict) else DEFAULT_EVENTS.copy()
+
+
+def public_config() -> dict[str, Any]:
+    config = _config_from_db()
+    masked = "https://discord.com/api/webhooks/••••••••" if config.webhook_url else ""
+    return {"enabled": config.enabled, "configured": bool(config.webhook_url), "webhook_url_masked": masked,
+            "events": _parse_events(config.events_json), "minimum_interval_seconds": config.minimum_interval_seconds}
+
+
+def update_config(*, enabled: bool, webhook_url: str | None, events: dict[str, bool], minimum_interval_seconds: int) -> dict[str, Any]:
+    with SessionLocal() as session:
+        config = session.get(DiscordAlertConfig, 1)
+        if config is None:
+            config = DiscordAlertConfig(id=1)
+            session.add(config)
+            session.flush()
+        if webhook_url == "":
+            config.webhook_url = ""
+        elif webhook_url is not None:
+            normalized_url = webhook_url.strip()
+            parsed = urlparse(normalized_url)
+            if parsed.scheme != "https" or parsed.hostname != "discord.com" or not parsed.path.startswith("/api/webhooks/") or parsed.username or parsed.password:
+                raise ValueError("Enter a valid Discord HTTPS webhook URL")
+            config.webhook_url = normalized_url
+        if minimum_interval_seconds < 0 or minimum_interval_seconds > 3600:
+            raise ValueError("Minimum alert interval must be between 0 and 3600 seconds")
+        config.enabled = enabled
+        config.events_json = json.dumps({key: bool(events.get(key, False)) for key in DEFAULT_EVENTS})
+        config.minimum_interval_seconds = minimum_interval_seconds
+        session.commit()
+    return public_config()
+
+
+def send_discord_message(content: str, *, title: str = "Monitoring alert", timeout_seconds: float = 8.0) -> None:
+    config = _config_from_db()
+    if not config.webhook_url:
+        raise ValueError("Configure a Discord webhook URL first")
+    payload = {
+        "username": WEBHOOK_USERNAME,
+        "avatar_url": WEBHOOK_AVATAR_URL,
+        "allowed_mentions": {"parse": []},
+        "embeds": [{
+            "title": title[:256],
+            "description": content[:4096],
+            "color": EMBED_BLUE,
+            "footer": {"text": "Synfull · AIO Monitoring Software"},
+        }],
+    }
+    request = Request(config.webhook_url, data=json.dumps(payload).encode("utf-8"),
+                      headers={"Content-Type": "application/json", "User-Agent": "Synfull/0.1"}, method="POST")
+    try:
+        with urlopen(request, timeout=timeout_seconds) as response:
+            if response.status not in (200, 204):
+                raise RuntimeError(f"Discord returned HTTP {response.status}")
+    except HTTPError as exc:
+        raise RuntimeError(f"Discord webhook returned HTTP {exc.code}") from None
+    except URLError:
+        raise RuntimeError("Could not reach Discord webhook. Check the connection and webhook URL.") from None
+
+
+def send_test_message() -> None:
+    send_discord_message(
+        "\n".join((
+            "✅ **Webhook connected successfully**",
+            "",
+            "Synfull can now deliver monitoring alerts to this channel.",
+        )),
+        title="Webhook test",
+    )
+
+
+class DockerEventMonitor:
+    def __init__(self, client_factory=None, interval_seconds: float = 2.0):
+        self._client_factory = client_factory or self._default_client
+        self._interval_seconds = interval_seconds
+        self._stop_event = threading.Event()
+        self._thread: threading.Thread | None = None
+        self._client = None
+        self._last_sent: dict[tuple[str, str], float] = {}
+        self._previous_states: dict[str, tuple[str, str]] = {}
+
+    @staticmethod
+    def _default_client():
+        import docker  # type: ignore[import-not-found]
+        settings = get_settings()
+        return docker.DockerClient(base_url=settings.docker_endpoint, timeout=5) if settings.docker_endpoint else docker.from_env(timeout=5)
+
+    def start(self) -> None:
+        if self._thread and self._thread.is_alive():
+            return
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self._run, name="synfull-docker-alerts", daemon=True)
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._stop_event.set()
+        if self._client is not None:
+            try:
+                self._client.close()
+            except Exception:
+                pass
+            self._client = None
+        if self._thread:
+            self._thread.join(timeout=2)
+
+    def _run(self) -> None:
+        while not self._stop_event.is_set():
+            try:
+                with SessionLocal() as session:
+                    config = session.get(DiscordAlertConfig, 1)
+                    enabled = bool(config and config.enabled and config.webhook_url)
+            except Exception as exc:
+                logger.debug("Unable to read Docker alert settings: %s", exc)
+                self._stop_event.wait(self._interval_seconds)
+                continue
+            if not enabled:
+                self._stop_event.wait(self._interval_seconds)
+                continue
+            try:
+                client = self._client_factory()
+                self._client = client
+                try:
+                    for event in client.events(decode=True, filters={"type": "container", "event": ["start", "stop", "die", "restart"]}):
+                        if self._stop_event.is_set():
+                            return
+                        self.process_event(event)
+                finally:
+                    if self._client is client:
+                        self._client = None
+                    close = getattr(client, "close", None)
+                    if close:
+                        close()
+            except Exception as exc:
+                if not self._stop_event.is_set():
+                    logger.debug("Docker event monitor reconnecting after error: %s", exc)
+                    self._stop_event.wait(self._interval_seconds)
+
+    def process_event(self, event: dict[str, Any]) -> bool:
+        config = _config_from_db()
+        if not config.enabled or not config.webhook_url:
+            return False
+        action = str(event.get("Action") or event.get("status") or "").lower()
+        actor = event.get("Actor") or {}
+        attributes = actor.get("Attributes") or {}
+        name = attributes.get("name") or event.get("id") or "unknown container"
+        container_id = str(event.get("id") or event.get("ID") or name)[:64]
+        if action == "die":
+            try:
+                exit_code = int(attributes.get("exitCode", "1"))
+            except (TypeError, ValueError):
+                exit_code = 1
+            event_key = "stop" if exit_code == 0 else "crash"
+        else:
+            event_key = action
+        events = _parse_events(config.events_json)
+        if event_key not in events or not events[event_key]:
+            return False
+        previous = self._previous_states.get(container_id)
+        if event_key == "crash" and previous and previous[0] == "stopped":
+            return False
+        if event_key == "start" and previous and previous[0] == "stopped" and events.get("restart"):
+            event_key = "restart"
+        self._previous_states[container_id] = ("stopped" if event_key in {"stop", "crash"} else "running", name)
+        now = time.monotonic()
+        throttle_key = (container_id, event_key)
+        if now - self._last_sent.get(throttle_key, 0) < config.minimum_interval_seconds:
+            return False
+        labels = {"start": "started", "stop": "stopped", "crash": "crashed unexpectedly", "restart": "restarted"}
+        titles = {"start": "Container started", "stop": "Container stopped", "crash": "Container crashed", "restart": "Container restarted"}
+        safe_name = str(name).replace("`", "ˋ")
+        try:
+            send_discord_message(
+                "\n".join((
+                    f"🐳 **Container:** `{safe_name}`",
+                    f"**ID:** `{container_id[:12]}`",
+                    f"**Event:** {labels[event_key].capitalize()}.",
+                )),
+                title=titles[event_key],
+            )
+            self._last_sent[throttle_key] = now
+            return True
+        except Exception as exc:
+            logger.warning("Unable to send Docker %s alert for %s: %s", event_key, name, exc)
+            return False
+
+
+monitor = DockerEventMonitor()

package/backend/app/integrations/status.py

@@ -0,0 +1,192 @@
+import json
+import re
+import shutil
+import subprocess
+from typing import Any
+
+from ..config import get_settings
+
+
+COMMAND_TIMEOUT_SECONDS = 3
+CONTAINER_ID_PATTERN = re.compile(r"^[a-fA-F0-9]{1,64}$")
+CONTAINER_NAME_PATTERN = re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$")
+
+
+def validate_container_identifier(container_id: str) -> str:
+    if not isinstance(container_id, str) or not (CONTAINER_ID_PATTERN.fullmatch(container_id) or CONTAINER_NAME_PATTERN.fullmatch(container_id)):
+        raise ValueError("Invalid Docker container identifier")
+    return container_id
+
+
+def docker_action(container_id: str, action: str) -> dict[str, Any]:
+    identifier = validate_container_identifier(container_id)
+    if action not in {"start", "stop", "restart"}:
+        raise ValueError("Unsupported Docker action")
+    try:
+        import docker  # type: ignore[import-not-found]
+    except ImportError as exc:
+        raise RuntimeError("Docker SDK is not installed; container actions are disabled") from exc
+    settings = get_settings()
+    client = docker.DockerClient(base_url=settings.docker_endpoint, timeout=COMMAND_TIMEOUT_SECONDS) if settings.docker_endpoint else docker.from_env(timeout=COMMAND_TIMEOUT_SECONDS)
+    container = client.containers.get(identifier)
+    getattr(container, action)(timeout=10) if action in {"stop", "restart"} else getattr(container, action)()
+    container.reload()
+    return {"id": container.short_id, "name": container.name, "state": container.status, "action": action}
+
+
+def docker_logs(container_id: str, tail: int = 300) -> dict[str, Any]:
+    identifier = validate_container_identifier(container_id)
+    if not 1 <= tail <= 2000:
+        raise ValueError("Log tail must be between 1 and 2000 lines")
+    try:
+        import docker  # type: ignore[import-not-found]
+    except ImportError as exc:
+        raise RuntimeError("Docker SDK is not installed; container logs are unavailable") from exc
+    settings = get_settings()
+    client = docker.DockerClient(base_url=settings.docker_endpoint, timeout=COMMAND_TIMEOUT_SECONDS) if settings.docker_endpoint else docker.from_env(timeout=COMMAND_TIMEOUT_SECONDS)
+    container = client.containers.get(identifier)
+    content = container.logs(tail=tail, timestamps=True, stdout=True, stderr=True)
+    if isinstance(content, bytes):
+        content = content.decode("utf-8", errors="replace")
+    return {"id": container.short_id, "name": container.name, "logs": content, "tail": tail}
+
+
+def _format_size(value: int) -> str:
+    amount = float(value)
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if amount < 1024 or unit == "TB":
+            return f"{amount:.1f} {unit}"
+        amount /= 1024
+    return f"{amount:.1f} TB"
+
+
+def _run(arguments: list[str]) -> tuple[int, str, str]:
+    try:
+        result = subprocess.run(arguments, capture_output=True, text=True, timeout=COMMAND_TIMEOUT_SECONDS,
+                                check=False, shell=False)
+        return result.returncode, result.stdout, result.stderr
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return 127, "", str(exc)
+
+
+def docker_status() -> dict[str, Any]:
+    settings = get_settings()
+    docker_bin = shutil.which("docker")
+    result: dict[str, Any] = {"installed": False, "available": False, "status": "unavailable",
+                              "message": "Docker CLI is not installed.", "containers": []}
+    try:
+        import docker  # type: ignore[import-not-found]
+    except ImportError:
+        docker_sdk = False
+    else:
+        docker_sdk = True
+    result["sdk_installed"] = docker_sdk
+    result["cli_installed"] = docker_bin is not None
+    result["installed"] = docker_sdk or docker_bin is not None
+    if docker_sdk:
+        try:
+            client = docker.DockerClient(base_url=settings.docker_endpoint, timeout=COMMAND_TIMEOUT_SECONDS) if settings.docker_endpoint else docker.from_env(timeout=COMMAND_TIMEOUT_SECONDS)
+            containers = client.containers.list(all=True)
+            normalized = []
+            for container in containers:
+                item = {"id": container.short_id, "name": container.name,
+                        "image": str(container.image.tags[0] if container.image.tags else container.image.short_id),
+                        "state": container.status, "cpu_percent": None, "memory_usage": None, "memory_percent": None}
+                if container.status == "running":
+                    try:
+                        stats = container.stats(stream=False)
+                        cpu = stats.get("cpu_stats", {})
+                        previous_cpu = stats.get("precpu_stats", {})
+                        cpu_delta = cpu.get("cpu_usage", {}).get("total_usage", 0) - previous_cpu.get("cpu_usage", {}).get("total_usage", 0)
+                        system_delta = cpu.get("system_cpu_usage", 0) - previous_cpu.get("system_cpu_usage", 0)
+                        cpu_count = cpu.get("online_cpus") or len(cpu.get("cpu_usage", {}).get("percpu_usage", [])) or 1
+                        if cpu_delta >= 0 and system_delta > 0:
+                            item["cpu_percent"] = round((cpu_delta / system_delta) * cpu_count * 100, 1)
+                        memory = stats.get("memory_stats", {})
+                        usage = memory.get("usage")
+                        cache = memory.get("stats", {}).get("inactive_file", memory.get("stats", {}).get("cache", 0))
+                        limit = memory.get("limit")
+                        if usage is not None:
+                            item["memory_usage"] = _format_size(max(0, usage - cache))
+                        if usage is not None and limit:
+                            item["memory_percent"] = round(max(0, usage - cache) / limit * 100, 1)
+                    except Exception:
+                        pass
+                normalized.append(item)
+            result.update(available=True, status="available", message="Docker daemon is reachable.", containers=normalized)
+            result["running"] = sum(c["state"] == "running" for c in result["containers"])
+            return result
+        except Exception as exc:
+            result.update(status="unavailable", message=f"Docker daemon is not reachable: {exc}")
+    if docker_bin:
+        code, stdout, stderr = _run([docker_bin, "ps", "--all", "--format", "{{json .}}"])
+        if code == 0:
+            containers = []
+            for line in stdout.splitlines():
+                try:
+                    row = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                containers.append({"id": row.get("ID", ""), "name": row.get("Names", ""),
+                                   "image": row.get("Image", ""), "state": row.get("State", "unknown")})
+            stats_code, stats_output, _ = _run([docker_bin, "stats", "--no-stream", "--format", "{{json .}}"])
+            if stats_code == 0:
+                stats_by_name = {}
+                for line in stats_output.splitlines():
+                    try:
+                        row = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    stats_by_name[row.get("Name", "")] = row
+                for container in containers:
+                    stats = stats_by_name.get(container["name"])
+                    if stats:
+                        container.update(cpu_percent=stats.get("CPUPerc"), memory_usage=stats.get("MemUsage"),
+                                         memory_percent=stats.get("MemPerc"))
+                    else:
+                        container.update(cpu_percent=None, memory_usage=None, memory_percent=None)
+            else:
+                for container in containers:
+                    container.update(cpu_percent=None, memory_usage=None, memory_percent=None)
+            result.update(available=True, status="available", message="Docker daemon is reachable.", containers=containers,
+                          running=sum(c["state"] == "running" for c in containers))
+        else:
+            result.update(status="unavailable", message=(stderr.strip() or "Docker daemon is stopped or inaccessible."))
+    return result
+
+
+def pm2_status() -> dict[str, Any]:
+    settings = get_settings()
+    executable = settings.pm2_executable or shutil.which("pm2")
+    result: dict[str, Any] = {"installed": executable is not None, "available": False,
+                              "status": "unavailable", "message": "PM2 is not installed.", "processes": []}
+    if executable is None:
+        return result
+    result["message"] = "PM2 is installed but its process list is unavailable."
+    code, stdout, stderr = _run([executable, "jlist"])
+    if code != 0:
+        result["message"] = stderr.strip() or "PM2 process list is inaccessible for the configured user."
+        return result
+    try:
+        rows = json.loads(stdout)
+        if not isinstance(rows, list):
+            raise ValueError("PM2 returned an unexpected process list")
+    except (json.JSONDecodeError, ValueError) as exc:
+        result["message"] = f"Could not parse PM2 process list: {exc}"
+        return result
+    processes = []
+    for row in rows:
+        env = row.get("pm2_env") or {}
+        monit = row.get("monit") or {}
+        processes.append({"id": row.get("pm_id"), "name": row.get("name"),
+                          "status": env.get("status", "unknown"), "cpu_percent": monit.get("cpu"),
+                          "memory_bytes": monit.get("memory"), "uptime_ms": env.get("pm_uptime")})
+    result.update(available=True, status="available", message="PM2 process list is available.", processes=processes,
+                  running=sum(p["status"] == "online" for p in processes))
+    if settings.pm2_owner:
+        result["configured_owner"] = settings.pm2_owner
+    return result
+
+
+def integrations_status() -> dict[str, dict[str, Any]]:
+    return {"docker": docker_status(), "pm2": pm2_status()}

package/backend/app/main.py

@@ -0,0 +1,52 @@
+from pathlib import Path
+
+from contextlib import asynccontextmanager
+import threading
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from .api.routes import router
+
+from .integrations.discord_alerts import monitor
+from .services.management import monitor_loop
+
+
+@asynccontextmanager
+async def lifespan(_app: FastAPI):
+    monitor.start()
+    stop_event = threading.Event()
+    management_thread = threading.Thread(target=monitor_loop, args=(stop_event,), name="synfull-monitoring", daemon=True)
+    management_thread.start()
+    try:
+        yield
+    finally:
+        stop_event.set()
+        management_thread.join(timeout=3)
+        monitor.stop()
+
+
+app = FastAPI(title="Synfull", version="0.1.0", lifespan=lifespan)
+app.include_router(router)
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+
+_FRONTEND_DIST = Path(__file__).resolve().parents[2] / "frontend" / "dist"
+if (_FRONTEND_DIST / "assets").is_dir():
+    app.mount("/assets", StaticFiles(directory=_FRONTEND_DIST / "assets"), name="assets")
+
+
+@app.get("/{path:path}", include_in_schema=False)
+def frontend(path: str):
+    if path.startswith("api/") or path in {"docs", "redoc", "openapi.json", "health"}:
+        raise HTTPException(status_code=404)
+    index = _FRONTEND_DIST / "index.html"
+    if not index.is_file():
+        raise HTTPException(status_code=404, detail="Frontend assets are not built")
+    from .services.management import auth_status
+    return FileResponse(index, headers={"Cache-Control": "no-store"} if auth_status()["setup_required"] else None)

package/backend/app/schemas/alerts.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel, Field, field_validator
+
+
+DEFAULT_DOCKER_ALERT_EVENTS = {"start", "stop", "crash", "restart"}
+
+
+class DiscordAlertUpdate(BaseModel):
+    enabled: bool
+    events: dict[str, bool] = Field(default_factory=lambda: {"start": True, "stop": True, "crash": True, "restart": True})
+    minimum_interval_seconds: int = Field(default=60, ge=0, le=3600)
+    webhook_url: str | None = None
+    clear_webhook: bool = False
+
+    @field_validator("events")
+    @classmethod
+    def validate_event_keys(cls, value: dict[str, bool]) -> dict[str, bool]:
+        if set(value) != DEFAULT_DOCKER_ALERT_EVENTS:
+            raise ValueError("Choose a value for each supported Docker alert event")
+        return value

package/backend/app/schemas/management.py

@@ -0,0 +1,63 @@
+from pydantic import BaseModel, Field
+
+
+class AdminSetup(BaseModel):
+    setup_token: str = Field(min_length=16, max_length=256)
+    username: str = Field(min_length=1, max_length=80)
+    password: str = Field(min_length=12, max_length=256)
+
+
+class LoginPayload(BaseModel):
+    username: str = Field(min_length=1, max_length=80)
+    password: str = Field(min_length=1, max_length=256)
+
+
+class PasswordChange(BaseModel):
+    new_password: str = Field(min_length=12, max_length=256)
+
+
+class ServiceAllowlistUpdate(BaseModel):
+    services: list[str] = Field(max_length=250)
+
+
+class EndpointTarget(BaseModel):
+    name: str = Field(min_length=1, max_length=100)
+    url: str = Field(min_length=8, max_length=2048)
+
+
+class EndpointTargetsUpdate(BaseModel):
+    targets: list[EndpointTarget] = Field(max_length=100)
+
+
+class BackupTarget(BaseModel):
+    name: str = Field(min_length=1, max_length=100)
+    path: str = Field(min_length=1, max_length=1024)
+    max_age_hours: int = Field(default=48, ge=1, le=8760)
+
+
+class BackupTargetsUpdate(BaseModel):
+    targets: list[BackupTarget] = Field(max_length=100)
+
+
+class ThresholdUpdate(BaseModel):
+    thresholds: dict[str, float]
+
+
+class UserCreate(BaseModel):
+    username: str = Field(min_length=1, max_length=80)
+    password: str = Field(min_length=12, max_length=256)
+    role: str = Field(pattern="^(admin|guest)$")
+    permissions: list[str] = Field(default_factory=list, max_length=32)
+    theme: str = Field(default="synfull", pattern="^(synfull|monochrome|hacker|light|oled)$")
+
+
+class UserUpdate(BaseModel):
+    role: str = Field(pattern="^(admin|guest)$")
+    enabled: bool = True
+    permissions: list[str] = Field(default_factory=list, max_length=32)
+    password: str | None = Field(default=None, min_length=12, max_length=256)
+    theme: str | None = Field(default=None, pattern="^(synfull|monochrome|hacker|light|oled)$")
+
+
+class ThemeUpdate(BaseModel):
+    theme: str = Field(pattern="^(synfull|monochrome|hacker|light|oled)$")

package/backend/app/schemas/system.py

@@ -0,0 +1,30 @@
+from pydantic import BaseModel
+
+
+class SystemResponse(BaseModel):
+    platform: str
+    hostname: str
+    cpu_percent: float | None
+    per_cpu_percent: list[float] | None
+    memory_total: int | None
+    memory_used: int | None
+    memory_available: int | None
+    swap_total: int | None
+    swap_used: int | None
+    disks: list[dict]
+    networks: list[dict]
+    uptime_seconds: float | None
+    load_average: list[float] | None
+    temperatures: list[dict] | None
+
+
+class ProcessResponse(BaseModel):
+    pid: int
+    name: str | None
+    username: str | None
+    cpu_percent: float | None
+    memory_bytes: int | None
+    executable: str | None
+    command_line: list[str] | None
+    parent_pid: int | None
+    status: str | None