feat(api): expand API functionality

* Added ping/pong to WebSocket for connection testing.
* Added onboarding check and completion endpoints.
* Added thread pool support to `start-core-service` endpoint.
* Introduced endpoints for core and optional services, including service descriptions.
* Added `get_config` to return the entire config from the root endpoint.
* Updated config update logic to use root endpoint.
* Ensured `running_processes` file is created on initialization if missing.

feat(config): add origin field to config

* Added `origin` field to `dumb_config.json`.
* Updated schema in `dumb_config_schema.json`.
* Enhanced environment handling in `setup.py` to include `ORIGIN`.

feat(config): enhance service management

* Enables dynamic service creation and management via API.
* Adds simplified process for starting core services with dependency resolution.
* Provides detailed service descriptions and configurable options.
* Enhances config validation and error handling.

fix(decypharr): handle missing config file gracefully

* Updated `patch_decypharr_config` to return a message when the config file is not found.

fix(rclone): prevent overwriting config with multiple instances

* Fixed issue where multiple Rclone instances could cause config overwrites.

refactor(rclone): streamline setup logic and reduce redundancy

* Refactored Rclone setup logic for clearer configuration handling.
* Introduced helper functions for loading and writing config files.
* Simplified instance logic for handling key types.

fix(zurg): add version comparison during setup

* Allows switching between Zurg repositories even when `auto_update` is disabled.

chore(deps): update backend dependencies

* `certifi` → 2025.7.14
* `jsonschema` → 4.25.0
* `rpds-py` → 0.26.0
* `scalar-fastapi` → 1.2.2
* `typing-extensions` → 4.14.1
* `xmltodict` → 0.14.2

Author: I-am-PUID-0

.devcontainer/devcontainer.json

@@ -56,5 +56,5 @@
     "--shm-size=128m",
     "--pull=always"
   ],
-  "postCreateCommand": "apt update && apt install -y gcc python3.11-dev libpq-dev && curl -sSL https://install.python-poetry.org | python - && export PATH=\"$HOME/.local/bin:$PATH\" && poetry config virtualenvs.create false && poetry install --no-root --with dev && git config --global --add safe.directory /workspace"
+  "postCreateCommand": "apt update && apt install -y gcc python3.11-dev libpq-dev && apt remove -y python3-yaml && curl -sSL https://install.python-poetry.org | python - && export PATH=\"$HOME/.local/bin:$PATH\" && poetry config virtualenvs.create false && poetry install --no-root --with dev && git config --global --add safe.directory /workspace"
 }

README.md

@@ -115,7 +115,6 @@ services:
       - TZ=
       - PUID=
       - PGID=
-      - DUMB_LOG_LEVEL=INFO
     # network_mode: container:gluetun                                ## Example to attach to gluetun vpn container if realdebrid blocks IP address
     ports:
       - "3005:3005"                                                  ## DUMB Frontend
@@ -179,15 +178,15 @@ format: `<HOST_DIR>:<CONTAINER_DIR>[:PERMISSIONS]`.
 | `/config`             | rw          | This is where the application stores the rclone.conf, and any files needing persistence. CAUTION: rclone.conf is overwritten upon start/restart of the container. Do NOT use an existing rclone.conf file if you have other rclone services |
 | `/log`                | rw          | This is where the application stores its log files                                                                                                                                                                                          |
 | `/zurg/RD`            | rw          | This is where Zurg will store the active configuration and data for RealDebrid.                                                                                                                                                             |
-| `/riven/data`         | rw          | This is where Riven will store its data.                                                                                                                                                                                                    |
+| `/riven/backend/data` | rw          | This is where Riven will store its data.                                                                                                                                                                                                    |
 | `/postgres_data`      | rw          | This is where PostgreSQL will store its data.                                                                                                                                                                                               |
 | `/pgadmin/data`       | rw          | This is where pgAdmin 4 will store its data.                                                                                                                                                                                                |
 | `/plex_debrid/config` | rw          | This is where plex_debrid will store its data.                                                                                                                                                                                              |
 | `/cli_debrid/data`    | rw          | This is where cli_debrid will store its data.                                                                                                                                                                                               |
 | `/phalanx_db/data`    | rw          | This is where phalanx_db will store its data.                                                                                                                                                                                               |
 | `/decypharr`          | rw          | This is where decypharr will store its data.                                                                                                                                                                                                |
 | `/plex`               | rw          | This is where Plex Media Server will store its data.                                                                                                                                                                                        |
-| `/mnt/debrid`         | rw          | This is where the symlinks and rclone mounts will be stored                                                                                                                                                                                       |
+| `/mnt/debrid`         | rw          | This is where the symlinks and rclone mounts will be stored                                                                                                                                                                                 |
 
 ## 📝 TODO
 

api/api_state.py

@@ -20,6 +20,8 @@ def _load_status_from_file(self):
             self.logger.debug(
                 f"Status file {self.status_file_path} not found. Initializing empty status."
             )
+            with open(self.status_file_path, "w") as f:
+                f.write("{}")
             return {}
         except Exception as e:
             self.logger.error(f"Error loading status file: {e}")

api/routers/config.py

@@ -1,5 +1,5 @@
-from fastapi import APIRouter, HTTPException, Depends
-from typing import Union
+from fastapi import APIRouter, HTTPException, Depends, Query
+from typing import Union, Optional, Dict, Any
 from pydantic import BaseModel
 from utils.dependencies import get_logger, resolve_path
 from utils.config_loader import CONFIG_MANAGER, find_service_config
@@ -9,9 +9,9 @@
 import os, json, configparser, xmltodict
 
 
-class UpdateServiceConfigRequest(BaseModel):
-    process_name: str
-    updates: dict
+class ConfigUpdateRequest(BaseModel):
+    process_name: Optional[str] = None
+    updates: Dict[str, Any]
     persist: bool = False
 
 
@@ -359,87 +359,111 @@ def find_schema(schema, path_parts):
     return schema_section
 
 
-@config_router.post("/update-dmb-config")
-async def update_dumb_config(
-    request: UpdateServiceConfigRequest, logger=Depends(get_logger)
+@config_router.get("/")
+async def get_config(
+    process_name: Optional[str] = Query(
+        None, description="If set, return only that service’s config"
+    ),
+    logger=Depends(get_logger),
 ):
-    process_name = request.process_name
-    updates = request.updates
-    persist = request.persist
-
-    logger.info(f"Received update request for {process_name} with persist={persist}")
-
-    service_config, service_path = find_service_config(
-        CONFIG_MANAGER.config, process_name
-    )
+    if process_name:
+        service_cfg, _ = find_service_config(CONFIG_MANAGER.config, process_name)
+        if not service_cfg:
+            logger.error(f"Service not found: {process_name}")
+            raise HTTPException(status_code=404, detail="Service not found")
+        return service_cfg
 
-    if not service_config:
-        logger.error(f"Service not found: {process_name}")
-        raise HTTPException(status_code=404, detail="Service not found.")
+    return CONFIG_MANAGER.config
 
-    path_parts = service_path.split(".")
-    logger.debug(f"Looking up schema for path for {process_name}: {service_path}")
 
-    instance_schema = find_schema(
-        CONFIG_MANAGER.schema.get("properties", {}), path_parts
-    )
+@config_router.post("/")
+async def update_config(
+    request: ConfigUpdateRequest,
+    logger=Depends(get_logger),
+):
+    if request.process_name:
+        process_name = request.process_name
+        updates = request.updates
+        persist = request.persist
 
-    if not instance_schema:
-        logger.error(f"Schema not found for process: {process_name}")
-        raise HTTPException(
-            status_code=400,
-            detail=f"Schema not found for process: {process_name}",
+        logger.info(
+            f"Received update request for service '{process_name}' (persist={persist})"
         )
 
-    logger.debug(f"Schema found for {process_name}")
-
-    try:
-        validate(instance=updates, schema=instance_schema)
-        logger.debug("Validation of updates successful.")
-    except ValidationError as e:
-        error_path = (
-            " -> ".join(map(str, e.absolute_path)) if e.absolute_path else "root"
-        )
-        raise HTTPException(
-            status_code=400,
-            detail=f"Validation error in updates at '{error_path}': {e.message}",
+        service_config, service_path = find_service_config(
+            CONFIG_MANAGER.config, process_name
         )
+        if not service_config:
+            logger.error(f"Service not found: {process_name}")
+            raise HTTPException(status_code=404, detail="Service not found.")
 
-    try:
-        temp_config = {**service_config, **updates}
-        validate(instance=temp_config, schema=instance_schema)
-        logger.debug("Validation of merged configuration successful.")
-    except ValidationError as e:
-        error_path = (
-            " -> ".join(map(str, e.absolute_path)) if e.absolute_path else "root"
-        )
-        raise HTTPException(
-            status_code=400,
-            detail=f"Validation error in merged configuration at '{error_path}': {e.message}",
+        path_parts = service_path.split(".")
+        instance_schema = find_schema(
+            CONFIG_MANAGER.schema.get("properties", {}), path_parts
         )
+        if not instance_schema:
+            logger.error(f"Schema not found for service: {process_name}")
+            raise HTTPException(
+                status_code=400,
+                detail=f"Schema not found for service: {process_name}",
+            )
+        try:
+            validate(instance=updates, schema=instance_schema)
+        except ValidationError as e:
+            loc = " -> ".join(map(str, e.absolute_path)) or "root"
+            raise HTTPException(
+                status_code=400,
+                detail=f"Validation error in updates at '{loc}': {e.message}",
+            )
+
+        try:
+            merged = {**service_config, **updates}
+            validate(instance=merged, schema=instance_schema)
+        except ValidationError as e:
+            loc = " -> ".join(map(str, e.absolute_path)) or "root"
+            raise HTTPException(
+                status_code=400,
+                detail=f"Validation error in merged config at '{loc}': {e.message}",
+            )
 
-    try:
         for key, value in updates.items():
             if key in service_config:
                 service_config[key] = value
             else:
-                logger.error(f"Invalid key {key} in updates.")
+                logger.error(f"Invalid configuration key for {process_name}: {key}")
                 raise HTTPException(
                     status_code=400, detail=f"Invalid configuration key: {key}"
                 )
 
         if persist:
-            logger.info(f"Saving configuration for {process_name}")
+            logger.info(f"Persisting updated config for service '{process_name}'")
             CONFIG_MANAGER.save_config(process_name=process_name)
 
-        return {"status": "Config updated successfully", "persisted": persist}
+        return {
+            "status": "service config updated",
+            "process_name": process_name,
+            "persisted": persist,
+        }
 
-    except Exception as e:
-        logger.error(f"Failed to update configuration: {e}")
+    updates = request.updates
+    if not updates:
         raise HTTPException(
-            status_code=500, detail=f"Failed to update configuration: {str(e)}"
+            status_code=400, detail="No updates provided for global config."
         )
 
+    logger.info("Performing global config update (deep merge)")
+
+    for key, value in updates.items():
+        existing = CONFIG_MANAGER.config.get(key)
+        if isinstance(value, dict) and isinstance(existing, dict):
+            existing.update(value)
+        else:
+            CONFIG_MANAGER.config[key] = value
+
+    CONFIG_MANAGER.save_config()
+
+    return {"status": "global config updated", "keys": list(updates.keys())}
+
 
 @config_router.post("/service-config")
 async def handle_service_config(
@@ -541,3 +565,22 @@ async def get_service_ui_links(logger=Depends(get_logger)):
     except Exception as e:
         logger.error(f"Failed to fetch services: {e}")
         raise HTTPException(status_code=500, detail="Failed to fetch services")
+
+
+@config_router.get("/onboarding-status")
+async def onboarding_status():
+    cfg = CONFIG_MANAGER.config
+    return {
+        "needs_onboarding": not cfg.get("dumb", {}).get("onboarding_completed", False)
+    }
+
+
+@config_router.post("/onboarding-completed")
+async def onboarding_completed(logger=Depends(get_logger)):
+    cfg = CONFIG_MANAGER.config
+    if "dumb" not in cfg:
+        cfg["dumb"] = {}
+    cfg["dumb"]["onboarding_completed"] = True
+    logger.info("Onboarding completed successfully.")
+    CONFIG_MANAGER.save_config()
+    return {"status": "Onboarding completed successfully"}