Add web-based Uptime Kuma login with TOTP support

- Add login modal for username/password/TOTP authentication
- Persist token to file for session persistence
- Make UPTIME_KUMA_API_KEY optional (can login via web UI)
- Add /api/kuma/auth, /api/kuma/login, /api/kuma/logout endpoints
- Show login prompt when not authenticated

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

backend/app.py

@@ -406,6 +406,52 @@ def create_suggested_monitors():
     return jsonify({"created": created})
 
 
+# Uptime Kuma authentication endpoints
+@app.route("/api/kuma/auth", methods=["GET"])
+def kuma_auth_status():
+    """Check if authenticated to Uptime Kuma."""
+    try:
+        kuma = get_kuma_client()
+        authenticated = kuma.is_authenticated()
+        config = get_config()
+        return jsonify({
+            "authenticated": authenticated,
+            "url": config.uptime_kuma_url,
+        })
+    except Exception as e:
+        return jsonify({"authenticated": False, "error": str(e)})
+
+
+@app.route("/api/kuma/login", methods=["POST"])
+def kuma_login():
+    """Login to Uptime Kuma with username/password/TOTP."""
+    data = request.json
+    username = data.get("username")
+    password = data.get("password")
+    totp = data.get("totp")  # Optional
+
+    if not username or not password:
+        return jsonify({"error": "username and password are required"}), 400
+
+    try:
+        kuma = get_kuma_client()
+        result = kuma.login(username, password, totp)
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 401
+
+
+@app.route("/api/kuma/logout", methods=["POST"])
+def kuma_logout():
+    """Logout from Uptime Kuma."""
+    try:
+        kuma = get_kuma_client()
+        kuma.logout()
+        return jsonify({"status": "ok"})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
 # Test Uptime Kuma connection
 @app.route("/api/kuma/test", methods=["GET"])
 def test_kuma_connection():

backend/config.py

@@ -100,8 +100,7 @@ class Config:
             errors.append("SSH_PRIVATE_KEY is required")
         if not self.uptime_kuma_url:
             errors.append("UPTIME_KUMA_URL is required")
-        if not self.uptime_kuma_api_key:
-            errors.append("UPTIME_KUMA_API_KEY is required")
+        # UPTIME_KUMA_API_KEY is optional - can login via web UI
         if not self.claude_api_key:
             errors.append("CLAUDE_API_KEY is required")
         return errors

backend/services/kuma_client.py

@@ -1,3 +1,5 @@
+import os
+import json
 from typing import Optional
 from dataclasses import dataclass
 from uptime_kuma_api import UptimeKumaApi, MonitorType
@@ -15,6 +17,9 @@ TYPE_MAP = {
     "push": MonitorType.PUSH,
 }
 
+# Token storage path
+TOKEN_FILE = os.environ.get("KUMA_TOKEN_FILE", "/tmp/kuma_token.json")
+
 
 @dataclass
 class Monitor:
@@ -40,21 +45,68 @@ class Monitor:
             self.accepted_statuscodes = ["200-299"]
 
 
+def load_saved_token() -> Optional[str]:
+    """Load saved token from file."""
+    try:
+        if os.path.exists(TOKEN_FILE):
+            with open(TOKEN_FILE, "r") as f:
+                data = json.load(f)
+                return data.get("token")
+    except Exception:
+        pass
+    return None
+
+
+def save_token(token: str) -> None:
+    """Save token to file."""
+    try:
+        with open(TOKEN_FILE, "w") as f:
+            json.dump({"token": token}, f)
+    except Exception as e:
+        print(f"Warning: Could not save token: {e}")
+
+
+def clear_saved_token() -> None:
+    """Clear saved token."""
+    try:
+        if os.path.exists(TOKEN_FILE):
+            os.remove(TOKEN_FILE)
+    except Exception:
+        pass
+
+
 class UptimeKumaClient:
     """Client for Uptime Kuma using Socket.io API."""
 
     def __init__(self):
         config = get_config()
         self.base_url = config.uptime_kuma_url.rstrip("/")
-        self.api_key = config.uptime_kuma_api_key
+        self.api_key = config.uptime_kuma_api_key  # Can be empty if using saved token
         self._api = None
+        self._token = None
+
+    def _get_token(self) -> Optional[str]:
+        """Get token from config or saved file."""
+        if self._token:
+            return self._token
+        if self.api_key:
+            return self.api_key
+        return load_saved_token()
 
     def _get_api(self) -> UptimeKumaApi:
         """Get connected API instance."""
         if self._api is None:
+            token = self._get_token()
+            if not token:
+                raise Exception("Not authenticated. Please login to Uptime Kuma first.")
+
             self._api = UptimeKumaApi(self.base_url)
-            # Login with API key as token
-            self._api.login_by_token(self.api_key)
+            try:
+                self._api.login_by_token(token)
+            except Exception as e:
+                self._api = None
+                clear_saved_token()
+                raise Exception(f"Authentication failed. Please login again: {e}")
         return self._api
 
     def _disconnect(self):
@@ -66,6 +118,46 @@ class UptimeKumaClient:
                 pass
             self._api = None
 
+    def login(self, username: str, password: str, totp: Optional[str] = None) -> dict:
+        """Login with username/password and optional TOTP."""
+        self._disconnect()
+        try:
+            api = UptimeKumaApi(self.base_url)
+            if totp:
+                result = api.login(username, password, totp)
+            else:
+                result = api.login(username, password)
+
+            token = result.get("token")
+            if token:
+                save_token(token)
+                self._token = token
+
+            api.disconnect()
+            return {"success": True, "message": "Login successful"}
+        except Exception as e:
+            raise Exception(f"Login failed: {str(e)}")
+
+    def is_authenticated(self) -> bool:
+        """Check if we have valid authentication."""
+        token = self._get_token()
+        if not token:
+            return False
+        try:
+            api = UptimeKumaApi(self.base_url)
+            api.login_by_token(token)
+            api.disconnect()
+            return True
+        except Exception:
+            clear_saved_token()
+            return False
+
+    def logout(self) -> None:
+        """Clear saved authentication."""
+        self._disconnect()
+        self._token = None
+        clear_saved_token()
+
     def get_monitors(self) -> list[dict]:
         """Get all monitors."""
         try: