synfull 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Synfull contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,59 @@
-# Temporary Holding Version
+# Synfull
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Synfull is a local-first host monitoring dashboard for Windows and Linux, providing CPU, memory, disk, network, process, service, integration and host-event views through a browser interface and REST API.
+
+## Install from npm
+
+Requirements: Node.js 18+, Python 3.10+, and npm. The CLI creates its own Python virtual environment and installs the backend dependencies when needed. On Ubuntu/Debian, install `python3-venv` (or the matching `python3.X-venv` package) if venv creation reports that pip is missing. Linux may also require build prerequisites when a dependency has no wheel for the host platform.
+
+```sh
+npm install -g synfull
+synfull setup
+synfull start
+synfull open
+```
+
+The dashboard listens on **127.0.0.1:8000** only. The initial local login is username `admin`, password `admin`; Synfull will require you to set a new password of at least 12 characters before accessing the application. Do not expose the service publicly or through an untrusted proxy. npm installation alone does not register a background service or change system startup.
+
+### Commands
+
+- `synfull setup` prepares the isolated Python runtime and dependencies.
+- `synfull start` runs in the background; `synfull run` keeps the server in the foreground.
+- `synfull status`, `synfull stop`, and `synfull open` manage a manually started instance.
+- `synfull install-service` explicitly enables automatic start and restart. On Windows this registers a per-user logon scheduled task. On Linux it creates and enables a system-wide systemd service and therefore requires `sudo`; the service runs as your invoking user, not root.
+- `synfull uninstall-service` removes startup registration but retains application data.
+
+Use the same user account to install/start Synfull and install its startup service. Service registration is optional and is not performed during `npm install -g`.
+
+Configuration:
+
+- `SYNFULL_HOME` selects the CLI runtime/application directory.
+- `SYNFULL_STATE_DIR` selects persistent database and app state.
+- `SYNFULL_BIND_PORT` changes the localhost port (default `8000`). The listener is deliberately fixed to `127.0.0.1` in npm mode.
+
+## Development from source
+
+The source tree includes a Python FastAPI backend and a React/Vite frontend.
+
+```powershell
+.\scripts\dev.ps1
+```
+
+```sh
+python -m venv .venv
+python -m pip install -r backend/requirements.txt
+npm --prefix frontend ci
+npm --prefix frontend run build
+```
+
+Run the API from the repository root with `python -m uvicorn app.main:app --app-dir backend --host 127.0.0.1 --port 8000`. Tests: `python -m pytest backend/tests` and `npm --prefix frontend run lint`.
+
+## npm publishing
+
+Package metadata and the `synfull` executable live in the repository-root `package.json`. The publish package includes the backend, runtime requirements, CLI and built frontend, not development dependencies. `npm pack --dry-run` can be used to inspect the tarball contents before publishing.
+
+The package name `synfull` was checked against the public npm registry while preparing this release and appeared available. Publishing still requires an npm account with permission to claim/publish the name and should only be done by an authorized maintainer.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

package/backend/app/api/routes.py

@@ -0,0 +1,380 @@
+from dataclasses import asdict
+
+from fastapi import APIRouter, HTTPException, Query, Request, Response
+
+from ..collectors.processes import collect_processes
+from ..collectors.system import collect_system_metrics, platform_capabilities
+from ..config import get_settings
+from ..integrations.discord_alerts import public_config as discord_alert_config, send_test_message, update_config as update_discord_alert_config
+from ..integrations.status import docker_action, docker_logs, integrations_status
+from ..schemas.alerts import DiscordAlertUpdate
+from ..schemas.system import ProcessResponse, SystemResponse
+from ..schemas.management import AdminSetup, BackupTargetsUpdate, EndpointTargetsUpdate, LoginPayload, PasswordChange, ServiceAllowlistUpdate, ThresholdUpdate, ThemeUpdate, UserCreate, UserUpdate
+from ..services import management
+
+router = APIRouter(prefix="/api/v1")
+
+
+@router.get("/auth/status")
+def authentication_status(request: Request):
+    return management.auth_status(request.cookies.get(management.SESSION_COOKIE))
+
+
+@router.post("/auth/setup")
+def setup_administrator(payload: AdminSetup, response: Response, request: Request):
+    if not request.client or request.client.host not in {"127.0.0.1", "::1", "testclient"}:
+        raise HTTPException(status_code=403, detail="Initial administrator setup is available only from this host")
+    try:
+        token = management.create_admin(setup_token=payload.setup_token, username=payload.username, password=payload.password)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    response.set_cookie(management.SESSION_COOKIE, token, httponly=True, secure=request.url.scheme == "https",
+                        samesite="strict", max_age=management.SESSION_SECONDS, path="/")
+    return {"authenticated": True, "username": payload.username.strip(), "must_change_password": False}
+
+
+@router.post("/auth/login")
+def authenticate(payload: LoginPayload, response: Response, request: Request):
+    try:
+        client_ip = request.client.host if request.client else "unknown"
+        token = management.login(username=payload.username, password=payload.password, client_ip=client_ip)
+    except PermissionError as exc:
+        raise HTTPException(status_code=429, detail=str(exc)) from exc
+    except ValueError as exc:
+        raise HTTPException(status_code=401, detail=str(exc)) from exc
+    response.set_cookie(management.SESSION_COOKIE, token, httponly=True, secure=request.url.scheme == "https",
+                        samesite="strict", max_age=management.SESSION_SECONDS, path="/")
+    current = management.current_user(payload.username.strip())
+    return {"authenticated": True, "username": payload.username.strip(),
+            "must_change_password": current["must_change_password"]}
+
+
+@router.post("/auth/change-password")
+def update_own_password(payload: PasswordChange, request: Request, response: Response):
+    username = management.get_session_username(request.cookies.get(management.SESSION_COOKIE))
+    if not username:
+        raise HTTPException(status_code=401, detail="Sign in to change your password")
+    try:
+        token = management.change_password(username, payload.new_password)
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    response.set_cookie(management.SESSION_COOKIE, token, httponly=True, secure=request.url.scheme == "https",
+                        samesite="strict", max_age=management.SESSION_SECONDS, path="/")
+    return {"authenticated": True, "username": username, "must_change_password": False}
+
+
+@router.post("/auth/logout")
+def unauthenticate(request: Request, response: Response):
+    username = management.get_session_username(request.cookies.get(management.SESSION_COOKIE))
+    if username:
+        management.logout(request.cookies.get(management.SESSION_COOKIE), username)
+    response.delete_cookie(management.SESSION_COOKIE, path="/", httponly=True, samesite="strict")
+    return {"authenticated": False}
+
+
+@router.get("/auth/me")
+def current_administrator(request: Request):
+    username = management.require_admin(request)
+    return {"authenticated": True, "username": username}
+
+
+@router.get("/auth/preferences")
+def user_preferences(request: Request):
+    username = management.require_admin(request)
+    return management.current_user(username)
+
+
+@router.put("/auth/preferences/theme")
+@router.post("/auth/preferences/theme")
+def set_user_theme(payload: ThemeUpdate, request: Request):
+    username = management.require_admin(request)
+    return {"theme": management.update_theme(username, payload.theme)}
+
+
+@router.get("/management/users/permissions")
+def available_user_permissions(request: Request):
+    management.require_admin(request)
+    return {"permissions": management.USER_PERMISSIONS}
+
+
+@router.get("/management/users")
+def list_user_accounts(request: Request):
+    username = management.require_admin(request)
+    if management.current_user(username)["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Only administrators can manage user accounts")
+    return management.user_accounts()
+
+
+@router.post("/management/users")
+def add_user_account(payload: UserCreate, request: Request):
+    username = management.require_admin(request)
+    if management.current_user(username)["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Only administrators can manage user accounts")
+    try:
+        created = management.create_user(username=payload.username, password=payload.password, role=payload.role,
+                                         permissions=payload.permissions, theme=payload.theme)
+        management._audit(username=username, action="users.create", target=created["username"], details=f"Created {created['role']} account")
+        return created
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.put("/management/users/{user_id}")
+def change_user_account(user_id: int, payload: UserUpdate, request: Request):
+    username = management.require_admin(request)
+    if management.current_user(username)["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Only administrators can manage user accounts")
+    try:
+        updated = management.update_user(user_id, role=payload.role, enabled=payload.enabled,
+                                         permissions=payload.permissions, password=payload.password, theme=payload.theme)
+        management._audit(username=username, action="users.update", target=updated["username"], details="Updated account settings")
+        return updated
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.get("/system", response_model=SystemResponse)
+def system(request: Request):
+    management.require_admin(request)
+    return asdict(collect_system_metrics())
+
+
+@router.get("/processes", response_model=list[ProcessResponse])
+def processes(request: Request):
+    management.require_admin(request)
+    return collect_processes()
+
+
+@router.get("/capabilities")
+def capabilities(request: Request):
+    management.require_admin(request)
+    return platform_capabilities()
+
+
+@router.get("/integrations")
+def integrations(request: Request):
+    management.require_admin(request)
+    return integrations_status()
+
+
+@router.get("/docker/alerts/discord")
+def get_discord_alert_config(request: Request):
+    management.require_admin(request)
+    return discord_alert_config()
+
+
+@router.put("/docker/alerts/discord")
+def put_discord_alert_config(payload: DiscordAlertUpdate, request: Request):
+    management.require_admin(request)
+    current = discord_alert_config()
+    webhook_url = "" if payload.clear_webhook else (payload.webhook_url or None)
+    if payload.enabled and not current["configured"] and webhook_url is None:
+        raise HTTPException(status_code=400, detail="Set a Discord webhook URL before enabling alerts")
+    if payload.enabled and webhook_url == "":
+        raise HTTPException(status_code=400, detail="Set a Discord webhook URL before enabling alerts")
+    try:
+        result = update_discord_alert_config(enabled=payload.enabled, webhook_url=webhook_url,
+                                             events=payload.events,
+                                             minimum_interval_seconds=payload.minimum_interval_seconds)
+        management._audit(username=management.require_admin(request), action="docker.alerts.discord.update")
+        return result
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.post("/docker/alerts/discord/test")
+def test_discord_alert(request: Request):
+    management.require_admin(request)
+    try:
+        send_test_message()
+        management._audit(username=management.require_admin(request), action="docker.alerts.discord.test")
+        return {"sent": True, "message": "Test alert sent to Discord."}
+    except Exception as exc:
+        management._audit(username=management.require_admin(request), action="docker.alerts.discord.test", outcome="failed", details=str(exc))
+        raise HTTPException(status_code=503, detail=str(exc)) from exc
+
+
+@router.get("/docker/containers/{container_id}/logs")
+def container_logs(container_id: str, request: Request, tail: int = Query(default=300, ge=1, le=2000)):
+    management.require_admin(request)
+    try:
+        return docker_logs(container_id, tail)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except Exception as exc:
+        raise HTTPException(status_code=503, detail=str(exc)) from exc
+
+
+@router.post("/docker/containers/{container_id}/{action}")
+def manage_container(container_id: str, action: str, request: Request):
+    username = management.require_admin(request)
+    if action not in {"start", "stop", "restart"}:
+        raise HTTPException(status_code=400, detail="Action must be start, stop, or restart")
+    try:
+        result = docker_action(container_id, action)
+        management._audit(username=username, action=f"docker.{action}", target=result.get("name", container_id))
+        return result
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except Exception as exc:
+        management._audit(username=username, action=f"docker.{action}", target=container_id, outcome="failed", details=str(exc))
+        raise HTTPException(status_code=503, detail=str(exc)) from exc
+
+
+@router.get("/management/security")
+def security_summary(request: Request):
+    username = management.require_admin(request)
+    settings = get_settings()
+    return {"username": username, "bind_host": settings.bind_host, "bind_port": settings.bind_port,
+            "is_local_only": settings.bind_host in {"127.0.0.1", "localhost", "::1"},
+            "transport_is_https": request.url.scheme == "https",
+            "session_duration_seconds": management.SESSION_SECONDS,
+            "service_allowlist": management.management_settings()["service_allowlist"]}
+
+
+@router.get("/settings")
+def settings_summary(request: Request):
+    management.require_admin(request)
+    settings = get_settings()
+    return {
+        "bind_host": settings.bind_host,
+        "bind_port": settings.bind_port,
+        "state_dir": str(settings.state_dir),
+        "database_path": str(settings.resolved_database_path),
+        "log_dir": str(settings.resolved_log_dir),
+        "collection_interval_seconds": settings.collection_interval_seconds,
+        "metric_retention_days": settings.metric_retention_days,
+        "development": settings.development,
+        "docker_endpoint_configured": bool(settings.docker_endpoint),
+        "pm2_executable_configured": bool(settings.pm2_executable),
+        "pm2_owner": settings.pm2_owner,
+    }
+
+
+@router.get("/management/services")
+def services(request: Request):
+    management.require_admin(request)
+    configured = set(management.management_settings()["service_allowlist"])
+    return [{**service, "allowlisted": service["name"] in configured} for service in management.list_services()]
+
+
+@router.put("/management/services/allowlist")
+def save_service_allowlist(payload: ServiceAllowlistUpdate, request: Request):
+    username = management.require_admin(request)
+    try:
+        return {"services": management.update_service_allowlist(payload.services, username=username)}
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.post("/management/services/{name}/{action}")
+def control_service(name: str, action: str, request: Request):
+    username = management.require_admin(request)
+    try:
+        return management.service_action(name, action, username=username)
+    except PermissionError as exc:
+        raise HTTPException(status_code=403, detail=str(exc)) from exc
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except Exception as exc:
+        raise HTTPException(status_code=503, detail=str(exc)) from exc
+
+
+@router.get("/management/jobs")
+def jobs(request: Request):
+    management.require_admin(request)
+    return management.scheduled_jobs()
+
+
+@router.get("/management/endpoints")
+def endpoints(request: Request):
+    management.require_admin(request)
+    return management.endpoint_results()
+
+
+@router.put("/management/endpoints")
+def save_endpoints(payload: EndpointTargetsUpdate, request: Request):
+    username = management.require_admin(request)
+    try:
+        targets = management.save_endpoint_targets([target.model_dump() for target in payload.targets], username=username)
+        return {"targets": targets}
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.post("/management/endpoints/check")
+def check_endpoints(request: Request):
+    username = management.require_admin(request)
+    results = []
+    targets = management.management_settings()["endpoint_targets"]
+    for target in targets:
+        try:
+            result = management.check_endpoint(target)
+        except ValueError as exc:
+            result = {**target, "status": "unhealthy", "message": str(exc), "response_code": None,
+                      "response_ms": None, "tls_days_remaining": None}
+        results.append(result)
+    healthy = sum(result["status"] == "healthy" for result in results)
+    management._audit(
+        username=username,
+        action="network.endpoint.check",
+        target=f"{len(results)} endpoint(s)",
+        outcome="success" if healthy == len(results) else "failed",
+        details=f"Checked {len(results)} endpoint(s): {healthy} healthy, {len(results) - healthy} unhealthy.",
+    )
+    return results
+
+
+@router.get("/management/backups")
+def backups(request: Request):
+    management.require_admin(request)
+    return management.backup_results()
+
+
+@router.get("/management/storage/smart")
+def smart_storage(request: Request):
+    management.require_admin(request)
+    return management.smart_health()
+
+
+@router.put("/management/backups")
+def save_backups(payload: BackupTargetsUpdate, request: Request):
+    username = management.require_admin(request)
+    try:
+        targets = management.save_backup_targets([target.model_dump() for target in payload.targets], username=username)
+        return {"targets": targets}
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.get("/management/metrics/history")
+def metric_history(request: Request, hours: int = Query(default=24, ge=1, le=720)):
+    management.require_admin(request)
+    return management.metric_history(hours=hours)
+
+
+@router.get("/management/metrics/alerts")
+def metric_alert_state(request: Request):
+    management.require_admin(request)
+    return {"thresholds": management.management_settings()["thresholds"], "alerts": management.metric_alerts()}
+
+
+@router.put("/management/metrics/thresholds")
+def save_metric_thresholds(payload: ThresholdUpdate, request: Request):
+    username = management.require_admin(request)
+    try:
+        return {"thresholds": management.save_thresholds(payload.thresholds, username=username)}
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.get("/management/audit")
+def audit_log(request: Request, limit: int = Query(default=200, ge=1, le=500), offset: int = Query(default=0, ge=0)):
+    management.require_admin(request)
+    return management.audit_entries(limit=limit, offset=offset)
+
+
+@router.get("/management/logs")
+def logs(request: Request, query: str = Query(default="", max_length=200), limit: int = Query(default=200, ge=1, le=500)):
+    management.require_admin(request)
+    return management.system_logs(query=query, limit=limit)

package/backend/app/collectors/platform/__init__.py

@@ -0,0 +1,13 @@
+import platform
+
+from .linux import LinuxAdapter
+from .windows import WindowsAdapter
+
+
+def get_platform_adapter():
+    system = platform.system()
+    if system == "Windows":
+        return WindowsAdapter()
+    if system == "Linux":
+        return LinuxAdapter()
+    raise RuntimeError(f"Unsupported operating system: {system}")

package/backend/app/collectors/platform/base.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass
+from typing import Protocol
+
+
+@dataclass
+class SystemMetrics:
+    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 PlatformAdapter(Protocol):
+    def system_metrics(self) -> SystemMetrics: ...
+    def processes(self) -> list[dict]: ...
+    def capabilities(self) -> dict: ...

package/backend/app/collectors/platform/linux.py

@@ -0,0 +1,56 @@
+import platform
+import time
+
+import psutil
+
+from .base import SystemMetrics
+
+
+class LinuxAdapter:
+    def system_metrics(self) -> SystemMetrics:
+        memory = psutil.virtual_memory()
+        swap = psutil.swap_memory()
+        disks = []
+        for part in psutil.disk_partitions(all=False):
+            try:
+                usage = psutil.disk_usage(part.mountpoint)
+                disks.append({"device": part.device, "mountpoint": part.mountpoint, "filesystem": part.fstype,
+                              "total": usage.total, "used": usage.used, "free": usage.free})
+            except (PermissionError, OSError):
+                continue
+        io = psutil.net_io_counters(pernic=True) or {}
+        networks = [{"name": name, "bytes_sent": counters.bytes_sent, "bytes_received": counters.bytes_recv}
+                    for name, counters in io.items()]
+        temps = None
+        try:
+            sensor_data = psutil.sensors_temperatures()
+            temps = [{"sensor": name, "label": entry.label or name, "current": entry.current}
+                     for name, entries in (sensor_data or {}).items() for entry in entries]
+        except (AttributeError, OSError):
+            pass
+        load = list(psutil.getloadavg()) if hasattr(psutil, "getloadavg") else None
+        return SystemMetrics(platform.system(), platform.node(), psutil.cpu_percent(interval=None),
+                             psutil.cpu_percent(interval=None, percpu=True), memory.total, memory.used,
+                             memory.available, swap.total, swap.used, disks, networks,
+                             max(0.0, time.time() - psutil.boot_time()), load, temps)
+
+    def processes(self) -> list[dict]:
+        result = []
+        attrs = ["pid", "name", "username", "exe", "ppid", "status", "memory_info"]
+        for proc in psutil.process_iter(attrs=attrs, ad_value=None):
+            try:
+                data = proc.info
+                result.append({"pid": data["pid"], "name": data["name"], "username": data["username"],
+                               "executable": data["exe"], "command_line": None,
+                               "parent_pid": data["ppid"], "status": data["status"],
+                               "memory_bytes": data["memory_info"].rss if data["memory_info"] else None,
+                               "cpu_percent": proc.cpu_percent(interval=None)})
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                continue
+        return result
+
+    def capabilities(self) -> dict:
+        systemd = platform.system() == "Linux" and __import__("os").path.exists("/run/systemd/system")
+        return {"platform": "linux", "service_manager": "systemd" if systemd else None,
+                "temperature": hasattr(psutil, "sensors_temperatures"),
+                "load_average": hasattr(psutil, "getloadavg"), "process_management": False}

package/backend/app/collectors/platform/windows.py

@@ -0,0 +1,54 @@
+import platform
+import time
+
+import psutil
+
+from .base import SystemMetrics
+
+
+class WindowsAdapter:
+    def system_metrics(self) -> SystemMetrics:
+        memory = psutil.virtual_memory()
+        swap = psutil.swap_memory()
+        disks = []
+        for part in psutil.disk_partitions(all=False):
+            try:
+                usage = psutil.disk_usage(part.mountpoint)
+                disks.append({"device": part.device, "mountpoint": part.mountpoint, "filesystem": part.fstype,
+                              "total": usage.total, "used": usage.used, "free": usage.free})
+            except (PermissionError, OSError):
+                continue
+        io = psutil.net_io_counters(pernic=True) or {}
+        networks = [{"name": name, "bytes_sent": counters.bytes_sent, "bytes_received": counters.bytes_recv}
+                    for name, counters in io.items()]
+        temps = None
+        try:
+            sensor_data = psutil.sensors_temperatures()
+            temps = [{"sensor": name, "label": entry.label or name, "current": entry.current}
+                     for name, entries in (sensor_data or {}).items() for entry in entries]
+        except (AttributeError, OSError):
+            pass
+        boot = psutil.boot_time()
+        return SystemMetrics(platform.system(), platform.node(), psutil.cpu_percent(interval=None),
+                             psutil.cpu_percent(interval=None, percpu=True), memory.total, memory.used,
+                             memory.available, swap.total, swap.used, disks, networks,
+                             max(0.0, time.time() - boot), None, temps)
+
+    def processes(self) -> list[dict]:
+        result = []
+        attrs = ["pid", "name", "username", "exe", "ppid", "status", "memory_info"]
+        for proc in psutil.process_iter(attrs=attrs, ad_value=None):
+            try:
+                data = proc.info
+                result.append({"pid": data["pid"], "name": data["name"], "username": data["username"],
+                               "executable": data["exe"], "command_line": None,
+                               "parent_pid": data["ppid"], "status": data["status"],
+                               "memory_bytes": data["memory_info"].rss if data["memory_info"] else None,
+                               "cpu_percent": proc.cpu_percent(interval=None)})
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                continue
+        return result
+
+    def capabilities(self) -> dict:
+        return {"platform": "windows", "service_manager": "scm", "temperature": hasattr(psutil, "sensors_temperatures"),
+                "load_average": False, "process_management": False}

package/backend/app/collectors/processes.py

@@ -0,0 +1,7 @@
+from .platform import get_platform_adapter
+
+_adapter = get_platform_adapter()
+
+
+def collect_processes():
+    return _adapter.processes()

package/backend/app/collectors/system.py

@@ -0,0 +1,11 @@
+from .platform import get_platform_adapter
+
+_adapter = get_platform_adapter()
+
+
+def collect_system_metrics():
+    return _adapter.system_metrics()
+
+
+def platform_capabilities():
+    return _adapter.capabilities()