Skip to content

Self-hosted monitoring for homelabs: host and container metrics and uptime checks from all your machines in one dashboard, with an optional AI agent that diagnoses incidents and suggests fixes.

feat(main.py): gathering basic hardware data

karloks2005744ce8944e7d
diff --git a/src/backend/auth.py b/src/backend/auth.py
index d45c574..ece0c08 100644
--- a/src/backend/auth.py
+++ b/src/backend/auth.py
@@ -47,13 +47,6 @@ def record_audit_log(
steps: list[str] | None = None,
conversation_id: str | None = None,
event_type: str | None = None,
- command: str | None = None,
- command_reason: str | None = None,
- command_risk: str | None = None,
- approval_status: str | None = None,
- exit_code: int | None = None,
- stdout: str | None = None,
- stderr: str | None = None,
):
log_entry = AuditLog(
user_id=user_id,
@@ -64,13 +57,6 @@ def record_audit_log(
steps=json.dumps(steps or []),
conversation_id=conversation_id,
event_type=event_type,
- command=command,
- command_reason=command_reason,
- command_risk=command_risk,
- approval_status=approval_status,
- exit_code=exit_code,
- stdout=stdout,
- stderr=stderr,
)
db.add(log_entry)
db.commit()
@@ -86,13 +72,6 @@ def record_audit_log(
"created_at": log_entry.created_at.isoformat(),
"conversation_id": log_entry.conversation_id,
"event_type": log_entry.event_type,
- "command": log_entry.command,
- "command_reason": log_entry.command_reason,
- "command_risk": log_entry.command_risk,
- "approval_status": log_entry.approval_status,
- "exit_code": log_entry.exit_code,
- "stdout": log_entry.stdout,
- "stderr": log_entry.stderr,
}
@@ -132,37 +111,11 @@ def get_recent_logs(
"created_at": log.created_at.isoformat(),
"conversation_id": log.conversation_id,
"event_type": log.event_type,
- "command": log.command,
- "command_reason": log.command_reason,
- "command_risk": log.command_risk,
- "approval_status": log.approval_status,
- "exit_code": log.exit_code,
- "stdout": log.stdout,
- "stderr": log.stderr,
}
)
return result
-def ensure_default_user(db):
- email = "[email protected]"
- user = db.query(User).filter(User.email == email).first()
- if user:
- return user
-
- user = User(
- name="Admin User",
- email=email,
- password_hash=bcrypt.hashpw(b"admin123", bcrypt.gensalt()).decode("utf-8"),
- role="admin",
- is_active=True,
- )
- db.add(user)
- db.commit()
- db.refresh(user)
- return user
-
-
def register_user(db, redis_client, *, name: str, email: str, password: str):
normalized_name = name.strip()
normalized_email = email.strip().lower()
diff --git a/src/backend/config.py b/src/backend/config.py
index b0398bd..40842a7 100644
--- a/src/backend/config.py
+++ b/src/backend/config.py
@@ -19,3 +19,8 @@ LOGIN_RATE_LIMIT = int(os.getenv("LOGIN_RATE_LIMIT", "5"))
LOGIN_RATE_WINDOW_SECONDS = int(os.getenv("LOGIN_RATE_WINDOW_SECONDS", "60"))
REGISTER_RATE_LIMIT = int(os.getenv("REGISTER_RATE_LIMIT", "3"))
REGISTER_RATE_WINDOW_SECONDS = int(os.getenv("REGISTER_RATE_WINDOW_SECONDS", "3600"))
+CORS_ORIGINS = [
+ origin.strip()
+ for origin in os.getenv("CORS_ORIGINS", "http://localhost:5173,http://localhost:5174,http://localhost:5175,http://localhost:5176").split(",")
+ if origin.strip()
+]
diff --git a/src/backend/main.py b/src/backend/main.py
index 35e0aaf..38383f4 100644
--- a/src/backend/main.py
+++ b/src/backend/main.py
@@ -1,16 +1,25 @@
from __future__ import annotations
+import re
+import hashlib
+import secrets
+import hmac
+import threading
+import time
+from pathlib import Path
+from datetime import datetime, timedelta, timezone
from typing import Annotated
import redis
-from fastapi import Cookie, Depends, FastAPI, HTTPException, Query, Request, Response, status
+from fastapi import Cookie, Depends, FastAPI, Header, HTTPException, Query, Request, Response, status
from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import PlainTextResponse
from pydantic import BaseModel, EmailStr
-from sqlalchemy import text
+from sqlalchemy import inspect, text
-from .auth import authenticate_user, ensure_default_user, get_recent_logs, get_user_from_session, logout_user, record_audit_log, register_user
+from .auth import authenticate_user, get_recent_logs, get_user_from_session, logout_user, record_audit_log, register_user
from .db import SessionLocal, check_database, get_db
-from .models import AuditLog, Base, User
+from .models import AuditLog, Base, ChatMessage, ContainerMetric, Conversation, EnrollmentKey, HostMetric, IncidentAlert, PendingCollector, Server, User
from .db import engine
from .config import (
@@ -19,12 +28,13 @@ from .config import (
REDIS_URL,
REGISTER_RATE_LIMIT,
REGISTER_RATE_WINDOW_SECONDS,
+ CORS_ORIGINS,
SESSION_COOKIE_NAME,
SESSION_COOKIE_SECURE,
SESSION_TTL_SECONDS,
)
-from .rate_limit import enforce_login_limit, enforce_register_limit, reset_limits
-from ..agent.service import send_agent_message
+from .rate_limit import enforce_ip_limit, enforce_login_limit, enforce_register_limit, reset_limits
+from ..agent.service import delete_agent_conversation, send_agent_message
class RegisterRequest(BaseModel):
@@ -43,12 +53,65 @@ class AgentChatRequest(BaseModel):
message: str
+class ConversationRequest(BaseModel):
+ conversation_id: str
+ title: str = "New chat"
+
+
+class ServerRequest(BaseModel):
+ hostname: str
+ ip_address: str | None = None
+ check_interval_seconds: int = 60
+
+
+class EnrollRequest(BaseModel):
+ enroll_key: str
+ hostname: str
+ machine_id: str | None = None
+
+
+class CollectorRegisterRequest(BaseModel):
+ hostname: str
+ machine_id: str | None = None
+ os_info: str | None = None
+
+
+class MetricsIngestRequest(BaseModel):
+ server_id: int
+ server: dict = {}
+ host: dict = {}
+ containers: list[dict] = []
+
+
+def agent_error_message(exc: Exception) -> str:
+ """Turn provider failures into useful, non-sensitive chat text."""
+ raw_message = str(exc).strip()
+ normalized = raw_message.lower()
+ if any(marker in normalized for marker in ("resourceexhausted", "overloaded", "capacity", " 503", "status 503")):
+ prefix = "Gemini is currently overloaded or unavailable. Please try again shortly."
+ elif any(marker in normalized for marker in ("rate limit", "quota", " 429", "status 429")):
+ prefix = "Gemini rate limit or quota was reached. Please try again later."
+ elif any(marker in normalized for marker in ("timeout", "timed out", "deadline exceeded")):
+ prefix = "Gemini did not respond before the request timed out. Please try again."
+ else:
+ prefix = "Gemini could not complete this request."
+
+ if not raw_message:
+ return prefix
+ # Errors can include request headers or provider diagnostics: keep a short,
+ # redacted detail for the administrator without leaking credentials.
+ detail = re.sub(r"(?i)(api[_ -]?key|authorization|token)\s*[:=]\s*\S+", r"\1=[redacted]", raw_message)
+ detail = re.sub(r"AIza[\w-]+", "[redacted]", detail)[:300]
+ return f"{prefix} Provider error: {detail}"
+
+
redis_client = redis.Redis.from_url(REDIS_URL, decode_responses=True)
app = FastAPI(title="Homelab Agent API")
app.add_middleware(
CORSMiddleware,
- allow_origins=["http://localhost:5173", "http://localhost:5174", "http://localhost:5175", "http://localhost:5176"],
+ # Only needed when the dashboard is served from a different origin than /api.
+ allow_origins=CORS_ORIGINS,
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
@@ -64,18 +127,21 @@ def startup_event():
connection.execute(text("ALTER TABLE audit_logs ADD COLUMN IF NOT EXISTS steps TEXT"))
connection.execute(text("ALTER TABLE audit_logs ADD COLUMN IF NOT EXISTS conversation_id VARCHAR(255)"))
connection.execute(text("ALTER TABLE audit_logs ADD COLUMN IF NOT EXISTS event_type VARCHAR(50)"))
- connection.execute(text("ALTER TABLE audit_logs ADD COLUMN IF NOT EXISTS command TEXT"))
- connection.execute(text("ALTER TABLE audit_logs ADD COLUMN IF NOT EXISTS command_reason TEXT"))
- connection.execute(text("ALTER TABLE audit_logs ADD COLUMN IF NOT EXISTS command_risk VARCHAR(50)"))
- connection.execute(text("ALTER TABLE audit_logs ADD COLUMN IF NOT EXISTS approval_status VARCHAR(50)"))
- connection.execute(text("ALTER TABLE audit_logs ADD COLUMN IF NOT EXISTS exit_code INTEGER"))
- connection.execute(text("ALTER TABLE audit_logs ADD COLUMN IF NOT EXISTS stdout TEXT"))
- connection.execute(text("ALTER TABLE audit_logs ADD COLUMN IF NOT EXISTS stderr TEXT"))
- db = SessionLocal()
- try:
- ensure_default_user(db)
- finally:
- db.close()
+ for column, column_type in (
+ ("memory_limit_mb", "DOUBLE PRECISION"), ("net_rx_mb", "DOUBLE PRECISION"), ("net_tx_mb", "DOUBLE PRECISION"),
+ ("block_read_mb", "DOUBLE PRECISION"), ("block_write_mb", "DOUBLE PRECISION"), ("pids", "INTEGER"),
+ ("started_at", "VARCHAR(64)"), ("ports", "VARCHAR(512)"),
+ ):
+ connection.execute(text(f"ALTER TABLE container_metrics ADD COLUMN IF NOT EXISTS {column} {column_type}"))
+ if "servers" in inspect(engine).get_table_names():
+ columns = {column["name"] for column in inspect(engine).get_columns("servers")}
+ if "collector_token_hash" not in columns:
+ with engine.begin() as connection:
+ connection.execute(text("ALTER TABLE servers ADD COLUMN collector_token_hash VARCHAR(64)"))
+ if "machine_id" not in columns:
+ with engine.begin() as connection:
+ connection.execute(text("ALTER TABLE servers ADD COLUMN machine_id VARCHAR(64)"))
+ threading.Thread(target=_offline_watch_loop, name="offline-watch", daemon=True).start()
try:
redis_client.ping()
except Exception:
@@ -185,6 +251,356 @@ def auth_logout(
raise HTTPException(status_code=400, detail="No session id supplied.")
+
+def _current_user(session_id, db):
+ user = get_user_from_session(redis_client, session_id)
+ if not user:
+ raise HTTPException(status_code=401, detail="Session is invalid or expired.")
+ return user
+
+
[email protected]("/monitoring/overview")
+def monitoring_overview(session_id: Annotated[str | None, Cookie(alias=SESSION_COOKIE_NAME)] = None, db=Depends(get_db)):
+ user = _current_user(session_id, db)
+ servers = db.query(Server).filter(Server.owner_id == user["id"]).order_by(Server.created_at.desc()).all()
+ result = []
+ for server in servers:
+ metric = db.query(HostMetric).filter(HostMetric.server_id == server.id).order_by(HostMetric.time.desc()).first()
+ containers = db.query(ContainerMetric).filter(ContainerMetric.server_id == server.id).order_by(ContainerMetric.time.desc()).all()
+ latest = {}
+ for item in containers:
+ latest.setdefault(item.container_id, item)
+ result.append({
+ "id": server.id, "hostname": server.hostname, "ip_address": server.ip_address, "os_info": server.os_info,
+ "cpu_cores": server.cpu_cores, "total_ram_gb": server.total_ram_gb,
+ "check_interval_seconds": server.check_interval_seconds,
+ "last_seen_at": server.last_seen_at.isoformat() if server.last_seen_at else None,
+ "host": ({key: getattr(metric, key) for key in ("time", "cpu_utilization_pct", "load_1m", "load_5m", "load_15m", "ram_used_gb", "ram_available_gb", "ram_pct", "swap_pct", "disk_usage_pct", "disk_inodes_pct", "net_bytes_sent_mb", "net_bytes_recv_mb", "system_uptime_seconds")} if metric else None),
+ "containers": [{"container_id": c.container_id, "name": c.name, "image": c.image, "status": c.status, "restart_count": c.restart_count, "cpu_pct": c.cpu_pct, "memory_used_mb": c.memory_used_mb, "memory_pct": c.memory_pct, "healthcheck_status": c.healthcheck_status, "time": c.time.isoformat()} for c in latest.values()],
+ })
+ alerts = db.query(IncidentAlert).join(Server).filter(Server.owner_id == user["id"], IncidentAlert.status == "active").order_by(IncidentAlert.created_at.desc()).limit(20).all()
+ return {"servers": result, "pending_collectors": visible_pending_collectors(db), "alerts": [{"id": a.id, "server_id": a.server_id, "severity": a.severity, "title": a.title, "description": a.description, "created_at": a.created_at.isoformat()} for a in alerts]}
+
+
+CONTAINER_DETAIL_FIELDS = (
+ "status", "healthcheck_status", "restart_count", "cpu_pct", "memory_used_mb", "memory_limit_mb", "memory_pct",
+ "net_rx_mb", "net_tx_mb", "block_read_mb", "block_write_mb", "pids",
+)
+
+
[email protected]("/monitoring/servers/{server_id}/containers/{container_id}")
+def container_detail(server_id: int, container_id: str, limit: int = 60, session_id: Annotated[str | None, Cookie(alias=SESSION_COOKIE_NAME)] = None, db=Depends(get_db)):
+ user = _current_user(session_id, db)
+ server = db.query(Server).filter(Server.id == server_id, Server.owner_id == user["id"]).first()
+ if not server:
+ raise HTTPException(status_code=404, detail="Server not found.")
+ samples = (
+ db.query(ContainerMetric)
+ .filter(ContainerMetric.server_id == server.id, ContainerMetric.container_id == container_id)
+ .order_by(ContainerMetric.time.desc())
+ .limit(max(1, min(limit, 500)))
+ .all()
+ )
+ if not samples:
+ raise HTTPException(status_code=404, detail="Container not found.")
+ latest = samples[0]
+ return {
+ "server_id": server.id,
+ "hostname": server.hostname,
+ "container_id": latest.container_id,
+ "name": latest.name,
+ "image": latest.image,
+ "started_at": latest.started_at,
+ "ports": latest.ports,
+ "latest": {"time": latest.time.isoformat(), **{field: getattr(latest, field) for field in CONTAINER_DETAIL_FIELDS}},
+ "history": [{"time": s.time.isoformat(), **{field: getattr(s, field) for field in CONTAINER_DETAIL_FIELDS}} for s in reversed(samples)],
+ }
+
+
+def _hash_secret(value: str) -> str:
+ return hashlib.sha256(value.encode()).hexdigest()
+
+
[email protected]("/monitoring/enrollment-key")
+def get_enrollment_key(session_id: Annotated[str | None, Cookie(alias=SESSION_COOKIE_NAME)] = None, db=Depends(get_db)):
+ user = _current_user(session_id, db)
+ key = db.query(EnrollmentKey).filter(EnrollmentKey.owner_id == user["id"]).first()
+ return {"exists": key is not None, "created_at": key.created_at.isoformat() if key else None}
+
+
[email protected]("/monitoring/enrollment-key")
+def rotate_enrollment_key(session_id: Annotated[str | None, Cookie(alias=SESSION_COOKIE_NAME)] = None, db=Depends(get_db)):
+ """Create or replace the account's enrollment key. The plaintext is returned only once."""
+ user = _current_user(session_id, db)
+ plaintext = f"hlk_{secrets.token_urlsafe(32)}"
+ key = db.query(EnrollmentKey).filter(EnrollmentKey.owner_id == user["id"]).first()
+ if key:
+ key.key_hash = _hash_secret(plaintext)
+ key.created_at = datetime.now(timezone.utc)
+ else:
+ key = EnrollmentKey(owner_id=user["id"], key_hash=_hash_secret(plaintext))
+ db.add(key)
+ db.commit()
+ return {"enroll_key": plaintext, "created_at": key.created_at.isoformat()}
+
+
[email protected]("/monitoring/enrollment-key")
+def revoke_enrollment_key(session_id: Annotated[str | None, Cookie(alias=SESSION_COOKIE_NAME)] = None, db=Depends(get_db)):
+ user = _current_user(session_id, db)
+ db.query(EnrollmentKey).filter(EnrollmentKey.owner_id == user["id"]).delete()
+ db.commit()
+ return {"status": "revoked"}
+
+
[email protected]("/monitoring/collectors/enroll")
+def enroll_collector(payload: EnrollRequest, db=Depends(get_db)):
+ """Register (or re-register) a collector using the owner's enrollment key.
+
+ Servers are matched on machine_id, so a collector that lost its saved
+ credentials gets its existing server back with a fresh token.
+ """
+ key = db.query(EnrollmentKey).filter(EnrollmentKey.key_hash == _hash_secret(payload.enroll_key.strip())).first()
+ if not key:
+ raise HTTPException(status_code=401, detail="Enrollment key is invalid or has been rotated.")
+ hostname = payload.hostname.strip()[:255]
+ machine_id = (payload.machine_id or "").strip()[:64] or None
+ if not hostname:
+ raise HTTPException(status_code=400, detail="Hostname is required.")
+
+ server = None
+ if machine_id:
+ server = db.query(Server).filter(Server.owner_id == key.owner_id, Server.machine_id == machine_id).first()
+ if not server:
+ server = Server(owner_id=key.owner_id, hostname=hostname, machine_id=machine_id)
+ db.add(server)
+ token = secrets.token_urlsafe(32)
+ server.collector_token_hash = _hash_secret(token)
+ db.commit()
+ db.refresh(server)
+ return {"server_id": server.id, "collector_token": token, "check_interval_seconds": server.check_interval_seconds}
+
+
+PAIRING_ALPHABET = "ABCDEFGHJKMNPQRSTUVWXYZ23456789"
+PENDING_VISIBLE_SECONDS = 120
+PENDING_RETENTION = timedelta(days=1)
+MAX_PENDING_COLLECTORS = 100
+COLLECTOR_SOURCE = Path(__file__).resolve().parents[1] / "agent" / "collector.py"
+
+
+def _client_ip(request: Request) -> str:
+ return request.client.host if request.client else "unknown"
+
+
[email protected]("/collector.py", response_class=PlainTextResponse)
+def collector_source():
+ """Serve the collector so new machines can run it from a stock Python image."""
+ return PlainTextResponse(COLLECTOR_SOURCE.read_text(), media_type="text/x-python")
+
+
[email protected]("/monitoring/collectors/register")
+def register_collector(payload: CollectorRegisterRequest, request: Request, db=Depends(get_db)):
+ """Unauthenticated: a new collector asks to join and waits until a user clicks Add."""
+ ip_address = _client_ip(request)
+ enforce_ip_limit(redis_client, scope="collector-register", ip_address=ip_address, limit=30, window_seconds=3600)
+ hostname = payload.hostname.strip()[:255]
+ if not hostname:
+ raise HTTPException(status_code=400, detail="Hostname is required.")
+ machine_id = (payload.machine_id or "").strip()[:64] or None
+ if machine_id:
+ # A restarted collector replaces its own earlier request instead of piling up duplicates.
+ db.query(PendingCollector).filter(PendingCollector.machine_id == machine_id, PendingCollector.ip_address == ip_address, PendingCollector.status != "approved").delete(synchronize_session=False)
+ if db.query(PendingCollector).count() >= MAX_PENDING_COLLECTORS:
+ raise HTTPException(status_code=503, detail="Too many servers are waiting for approval.")
+ secret = secrets.token_urlsafe(32)
+ code = "".join(secrets.choice(PAIRING_ALPHABET) for _ in range(6))
+ pending = PendingCollector(
+ poll_secret_hash=_hash_secret(secret), pairing_code=f"{code[:3]}-{code[3:]}", hostname=hostname,
+ machine_id=machine_id, ip_address=ip_address[:64], os_info=(payload.os_info or "")[:255] or None,
+ )
+ db.add(pending)
+ db.commit()
+ return {"request_secret": secret, "pairing_code": pending.pairing_code, "poll_interval_seconds": 5}
+
+
[email protected]("/monitoring/collectors/register/poll")
+def poll_collector_registration(authorization: Annotated[str | None, Header()] = None, db=Depends(get_db)):
+ secret = authorization.removeprefix("Bearer ").strip() if authorization and authorization.startswith("Bearer ") else ""
+ pending = db.query(PendingCollector).filter(PendingCollector.poll_secret_hash == _hash_secret(secret)).first() if secret else None
+ if not pending:
+ raise HTTPException(status_code=404, detail="Registration request not found or expired.")
+ pending.last_poll_at = datetime.now(timezone.utc)
+ if pending.status != "approved":
+ db.commit()
+ return {"status": pending.status}
+ server = db.query(Server).filter(Server.id == pending.approved_server_id).first()
+ db.delete(pending)
+ if not server:
+ db.commit()
+ raise HTTPException(status_code=404, detail="The approved server was deleted.")
+ # The token is minted only now, so it never sits in the database in readable form.
+ token = secrets.token_urlsafe(32)
+ server.collector_token_hash = _hash_secret(token)
+ db.commit()
+ return {"status": "approved", "server_id": server.id, "collector_token": token, "check_interval_seconds": server.check_interval_seconds}
+
+
+def _pending_for_user(pending_id: int, db) -> PendingCollector:
+ pending = db.query(PendingCollector).filter(PendingCollector.id == pending_id, PendingCollector.status != "approved").first()
+ if not pending:
+ raise HTTPException(status_code=404, detail="Pending server not found.")
+ return pending
+
+
[email protected]("/monitoring/pending-collectors/{pending_id}/approve")
+def approve_pending_collector(pending_id: int, session_id: Annotated[str | None, Cookie(alias=SESSION_COOKIE_NAME)] = None, db=Depends(get_db)):
+ user = _current_user(session_id, db)
+ pending = _pending_for_user(pending_id, db)
+ server = None
+ if pending.machine_id:
+ server = db.query(Server).filter(Server.owner_id == user["id"], Server.machine_id == pending.machine_id).first()
+ if not server:
+ server = Server(owner_id=user["id"], hostname=pending.hostname, machine_id=pending.machine_id, ip_address=pending.ip_address, os_info=pending.os_info)
+ db.add(server)
+ db.flush()
+ pending.status = "approved"
+ pending.approved_server_id = server.id
+ db.commit()
+ return {"status": "approved", "server_id": server.id}
+
+
[email protected]("/monitoring/pending-collectors/{pending_id}/dismiss")
+def dismiss_pending_collector(pending_id: int, session_id: Annotated[str | None, Cookie(alias=SESSION_COOKIE_NAME)] = None, db=Depends(get_db)):
+ _current_user(session_id, db)
+ pending = _pending_for_user(pending_id, db)
+ pending.status = "dismissed"
+ db.commit()
+ return {"status": "dismissed"}
+
+
+def visible_pending_collectors(db, now: datetime | None = None) -> list[dict]:
+ """Pending and dismissed requests from collectors that are still polling."""
+ cutoff = (now or datetime.now(timezone.utc)) - timedelta(seconds=PENDING_VISIBLE_SECONDS)
+ rows = db.query(PendingCollector).filter(PendingCollector.status.in_(("pending", "dismissed"))).order_by(PendingCollector.created_at.desc()).all()
+ visible = []
+ for row in rows:
+ last_poll = row.last_poll_at if row.last_poll_at.tzinfo else row.last_poll_at.replace(tzinfo=timezone.utc)
+ if last_poll >= cutoff:
+ visible.append({"id": row.id, "hostname": row.hostname, "pairing_code": row.pairing_code, "ip_address": row.ip_address, "os_info": row.os_info, "status": row.status, "created_at": row.created_at.isoformat()})
+ return visible
+
+
+def purge_stale_pending(db, now: datetime | None = None) -> None:
+ cutoff = (now or datetime.now(timezone.utc)) - PENDING_RETENTION
+ db.query(PendingCollector).filter(PendingCollector.last_poll_at < cutoff).delete(synchronize_session=False)
+ db.commit()
+
+
+OFFLINE_AFTER_MISSED_CHECKS = 3
+OFFLINE_ALERT_DESCRIPTION = "The collector has stopped reporting. Check that the server is up and can reach the backend."
+
+
+def _offline_title(server: Server) -> str:
+ return f"Server {server.hostname} is offline"
+
+
+def mark_offline_servers(db, now: datetime | None = None) -> int:
+ """Raise one active alert per server that has missed several check-ins."""
+ now = now or datetime.now(timezone.utc)
+ raised = 0
+ for server in db.query(Server).filter(Server.last_seen_at.isnot(None)).all():
+ last_seen = server.last_seen_at if server.last_seen_at.tzinfo else server.last_seen_at.replace(tzinfo=timezone.utc)
+ if now - last_seen < timedelta(seconds=server.check_interval_seconds * OFFLINE_AFTER_MISSED_CHECKS):
+ continue
+ already_open = db.query(IncidentAlert).filter(IncidentAlert.server_id == server.id, IncidentAlert.status == "active", IncidentAlert.description == OFFLINE_ALERT_DESCRIPTION).first()
+ if not already_open:
+ db.add(IncidentAlert(server_id=server.id, severity="CRITICAL", title=_offline_title(server), description=OFFLINE_ALERT_DESCRIPTION))
+ raised += 1
+ db.commit()
+ return raised
+
+
+def _offline_watch_loop() -> None:
+ while True:
+ time.sleep(60)
+ db = SessionLocal()
+ try:
+ mark_offline_servers(db)
+ purge_stale_pending(db)
+ except Exception as exc: # keep the watcher alive through transient DB errors
+ print(f"Offline watch failed: {type(exc).__name__}: {exc}", flush=True)
+ finally:
+ db.close()
+
+
[email protected]("/monitoring/servers")
+def add_monitored_server(payload: ServerRequest, session_id: Annotated[str | None, Cookie(alias=SESSION_COOKIE_NAME)] = None, db=Depends(get_db)):
+ user = _current_user(session_id, db)
+ if not payload.hostname.strip() or not 15 <= payload.check_interval_seconds <= 86400:
+ raise HTTPException(status_code=400, detail="Hostname is required and interval must be between 15 and 86400 seconds.")
+ token = secrets.token_urlsafe(32)
+ token_hash = hashlib.sha256(token.encode()).hexdigest()
+ server = Server(owner_id=user["id"], hostname=payload.hostname.strip()[:255], ip_address=payload.ip_address, check_interval_seconds=payload.check_interval_seconds, collector_token_hash=token_hash)
+ db.add(server); db.commit(); db.refresh(server)
+ return {"id": server.id, "hostname": server.hostname, "check_interval_seconds": server.check_interval_seconds, "collector_token": token}
+
+
[email protected]("/monitoring/servers/{server_id}")
+def delete_monitored_server(server_id: int, session_id: Annotated[str | None, Cookie(alias=SESSION_COOKIE_NAME)] = None, db=Depends(get_db)):
+ user = _current_user(session_id, db)
+ server = db.query(Server).filter(Server.id == server_id, Server.owner_id == user["id"]).first()
+ if not server:
+ raise HTTPException(status_code=404, detail="Server not found.")
+
+ db.query(HostMetric).filter(HostMetric.server_id == server.id).delete(synchronize_session=False)
+ db.query(ContainerMetric).filter(ContainerMetric.server_id == server.id).delete(synchronize_session=False)
+ db.query(IncidentAlert).filter(IncidentAlert.server_id == server.id).delete(synchronize_session=False)
+ db.query(PendingCollector).filter(PendingCollector.approved_server_id == server.id).delete(synchronize_session=False)
+ db.delete(server)
+ db.commit()
+ return {"status": "deleted", "server_id": server_id}
+
+
[email protected]("/monitoring/servers/{server_id}/interval")
+def update_check_interval(server_id: int, payload: dict, session_id: Annotated[str | None, Cookie(alias=SESSION_COOKIE_NAME)] = None, db=Depends(get_db)):
+ user = _current_user(session_id, db)
+ server = db.query(Server).filter(Server.id == server_id, Server.owner_id == user["id"]).first()
+ interval = payload.get("check_interval_seconds")
+ if not server:
+ raise HTTPException(status_code=404, detail="Server not found.")
+ if not isinstance(interval, int) or not 15 <= interval <= 86400:
+ raise HTTPException(status_code=400, detail="Interval must be between 15 and 86400 seconds.")
+ server.check_interval_seconds = interval; db.commit()
+ return {"id": server.id, "check_interval_seconds": server.check_interval_seconds}
+
+
[email protected]("/monitoring/metrics/ingest")
+def ingest_metrics(payload: MetricsIngestRequest, authorization: Annotated[str | None, Header()] = None, session_id: Annotated[str | None, Cookie(alias=SESSION_COOKIE_NAME)] = None, db=Depends(get_db)):
+ server = db.query(Server).filter(Server.id == payload.server_id).first()
+ if not server:
+ raise HTTPException(status_code=404, detail="Server not found.")
+ token = authorization.removeprefix("Bearer ").strip() if authorization and authorization.startswith("Bearer ") else None
+ token_hash = hashlib.sha256(token.encode()).hexdigest() if token else None
+ if server.collector_token_hash and token_hash and hmac.compare_digest(server.collector_token_hash, token_hash):
+ pass
+ else:
+ user = _current_user(session_id, db)
+ if server.owner_id != user["id"]:
+ raise HTTPException(status_code=404, detail="Server not found.")
+ for field in ("hostname", "ip_address", "os_info", "cpu_cores", "total_ram_gb"):
+ if field in payload.server and payload.server[field] is not None:
+ setattr(server, field, payload.server[field])
+ db.add(HostMetric(server_id=server.id, **{k: v for k, v in payload.host.items() if k in HostMetric.__table__.columns.keys() and k not in {"id", "server_id", "time"}}))
+ for container in payload.containers:
+ if container.get("container_id") and container.get("status"):
+ allowed = {k: v for k, v in container.items() if k in ContainerMetric.__table__.columns.keys() and k not in {"id", "server_id", "time"}}
+ db.add(ContainerMetric(server_id=server.id, **allowed))
+ if str(container.get("status", "")).lower() in {"restarting", "unhealthy"}:
+ db.add(IncidentAlert(server_id=server.id, severity="CRITICAL", title=f"Container {container.get('name', container['container_id'])} is {container['status']}", description="Automatski detektirano pri zaprimanju metrika."))
+ server.last_seen_at = datetime.now(timezone.utc)
+ db.query(IncidentAlert).filter(IncidentAlert.server_id == server.id, IncidentAlert.status == "active", IncidentAlert.description == OFFLINE_ALERT_DESCRIPTION).update({"status": "resolved"}, synchronize_session=False)
+ db.commit()
+ return {"status": "accepted", "interval_seconds": server.check_interval_seconds}
+
@app.get("/dashboard/summary")
def dashboard_summary(
session_id: Annotated[str | None, Cookie(alias=SESSION_COOKIE_NAME)] = None,
@@ -197,13 +613,14 @@ def dashboard_summary(
total_users = db.query(User).count()
total_logs = db.query(AuditLog).count()
error_logs = db.query(AuditLog).filter(AuditLog.level.in_(["ERROR", "WARN"])).count()
+ health_checks = db.query(AuditLog).filter(AuditLog.event_type == "health_check_completed").count()
return {
"total_users": total_users,
"total_logs": total_logs,
"error_logs": error_logs,
"uptime": "99.97%",
- "commands_run": 1284,
+ "health_checks": health_checks,
}
@@ -220,6 +637,55 @@ def list_logs(
return {"logs": get_recent_logs(db, limit=100, user_id=user["id"], conversation_id=conversation_id)}
+def _conversation_payload(conversation: Conversation, messages: list[ChatMessage]) -> dict:
+ return {
+ "id": conversation.id,
+ "title": conversation.title,
+ "created_at": conversation.created_at.isoformat(),
+ "updated_at": conversation.updated_at.isoformat(),
+ "messages": [{"id": item.id, "role": item.role, "text": item.content, "created_at": item.created_at.isoformat()} for item in messages],
+ }
+
+
[email protected]("/conversations")
+def list_conversations(session_id: Annotated[str | None, Cookie(alias=SESSION_COOKIE_NAME)] = None, db=Depends(get_db)):
+ user = get_user_from_session(redis_client, session_id)
+ if not user:
+ raise HTTPException(status_code=401, detail="Session is invalid or expired.")
+ conversations = db.query(Conversation).filter(Conversation.user_id == user["id"]).order_by(Conversation.updated_at.desc()).all()
+ return {"conversations": [_conversation_payload(item, db.query(ChatMessage).filter(ChatMessage.conversation_id == item.id).order_by(ChatMessage.created_at).all()) for item in conversations]}
+
+
[email protected]("/conversations")
+def create_conversation(payload: ConversationRequest, session_id: Annotated[str | None, Cookie(alias=SESSION_COOKIE_NAME)] = None, db=Depends(get_db)):
+ user = get_user_from_session(redis_client, session_id)
+ if not user:
+ raise HTTPException(status_code=401, detail="Session is invalid or expired.")
+ if db.query(Conversation).filter(Conversation.id == payload.conversation_id).first():
+ raise HTTPException(status_code=409, detail="Conversation already exists.")
+ conversation = Conversation(id=payload.conversation_id, user_id=user["id"], title=payload.title.strip()[:255] or "New chat")
+ db.add(conversation)
+ db.commit()
+ db.refresh(conversation)
+ return _conversation_payload(conversation, [])
+
+
[email protected]("/conversations/{conversation_id}")
+def delete_conversation(conversation_id: str, session_id: Annotated[str | None, Cookie(alias=SESSION_COOKIE_NAME)] = None, db=Depends(get_db)):
+ user = get_user_from_session(redis_client, session_id)
+ if not user:
+ raise HTTPException(status_code=401, detail="Session is invalid or expired.")
+ conversation = db.query(Conversation).filter(Conversation.id == conversation_id, Conversation.user_id == user["id"]).first()
+ if not conversation:
+ raise HTTPException(status_code=404, detail="Conversation not found.")
+ db.query(ChatMessage).filter(ChatMessage.conversation_id == conversation_id).delete(synchronize_session=False)
+ db.query(AuditLog).filter(AuditLog.user_id == user["id"], AuditLog.conversation_id == conversation_id).delete(synchronize_session=False)
+ db.delete(conversation)
+ db.commit()
+ delete_agent_conversation(user["id"], conversation_id)
+ return {"status": "deleted"}
+
+
@app.post("/logs")
def create_log(
payload: dict,
@@ -240,13 +706,6 @@ def create_log(
steps=[str(step) for step in payload.get("steps", []) if str(step).strip()],
conversation_id=payload.get("conversation_id"),
event_type=payload.get("event_type"),
- command=payload.get("command"),
- command_reason=payload.get("command_reason"),
- command_risk=payload.get("command_risk"),
- approval_status=payload.get("approval_status"),
- exit_code=payload.get("exit_code"),
- stdout=payload.get("stdout"),
- stderr=payload.get("stderr"),
)
@@ -259,6 +718,13 @@ def agent_chat(payload: AgentChatRequest, session_id: Annotated[str | None, Cook
message = payload.message.strip()
if not message:
raise HTTPException(status_code=400, detail="Message is required.")
+ conversation = db.query(Conversation).filter(Conversation.id == payload.conversation_id, Conversation.user_id == user["id"]).first()
+ if not conversation:
+ raise HTTPException(status_code=404, detail="Conversation not found.")
+ db.add(ChatMessage(conversation_id=conversation.id, role="user", content=message))
+ if conversation.title == "New chat":
+ conversation.title = message[:255]
+ db.commit()
try:
response_text = send_agent_message(
@@ -268,29 +734,33 @@ def agent_chat(payload: AgentChatRequest, session_id: Annotated[str | None, Cook
command_logger=lambda event: record_audit_log(
db,
user_id=user["id"],
- source="command",
+ source="health_monitor",
task_title=message[:255],
steps=event.get("steps", []),
conversation_id=payload.conversation_id,
event_type=event.get("event_type"),
message=event.get("message", "Command event"),
level=event.get("level", "INFO"),
- command=event.get("command"),
- command_reason=event.get("reason"),
- command_risk=event.get("risk"),
- approval_status=event.get("approval_status"),
- exit_code=event.get("exit_code"),
- stdout=event.get("stdout"),
- stderr=event.get("stderr"),
),
)
except Exception as exc:
- raise HTTPException(status_code=503, detail="Agent is unavailable.") from exc
+ user_message = agent_error_message(exc)
+ record_audit_log(
+ db,
+ user_id=user["id"],
+ level="ERROR",
+ message=user_message[:255],
+ source="health_monitor",
+ task_title=message[:255],
+ steps=["The AI provider request failed before a health check could run."],
+ conversation_id=payload.conversation_id,
+ event_type="agent_error",
+ )
+ db.add(ChatMessage(conversation_id=conversation.id, role="agent", content=f"Error: {user_message}"))
+ db.commit()
+ raise HTTPException(status_code=503, detail={"message": user_message}) from exc
- command_lines = [line.removeprefix("[COMMAND]:").strip() for line in response_text.splitlines() if line.startswith("[COMMAND]:")]
steps = ["Received the task and evaluated the request.", "Generated a structured response for the requested task."]
- if command_lines:
- steps.append(f"Prepared {len(command_lines)} command(s) for review.")
record_audit_log(
db,
@@ -300,7 +770,10 @@ def agent_chat(payload: AgentChatRequest, session_id: Annotated[str | None, Cook
source="homie",
task_title=message[:255],
steps=steps,
+ conversation_id=conversation.id,
)
+ db.add(ChatMessage(conversation_id=conversation.id, role="agent", content=response_text))
+ db.commit()
return {"message": response_text}
diff --git a/src/backend/models.py b/src/backend/models.py
index 0e89748..f073549 100644
--- a/src/backend/models.py
+++ b/src/backend/models.py
@@ -1,7 +1,7 @@
from datetime import datetime, timezone
from typing import Optional
-from sqlalchemy import Boolean, DateTime, Integer, String, Text
+from sqlalchemy import Boolean, DateTime, Float, ForeignKey, Integer, String, Text
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
@@ -43,15 +43,134 @@ class AuditLog(Base):
steps: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
conversation_id: Mapped[Optional[str]] = mapped_column(String(255), nullable=True, index=True)
event_type: Mapped[Optional[str]] = mapped_column(String(50), nullable=True)
- command: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
- command_reason: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
- command_risk: Mapped[Optional[str]] = mapped_column(String(50), nullable=True)
- approval_status: Mapped[Optional[str]] = mapped_column(String(50), nullable=True)
- exit_code: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
- stdout: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
- stderr: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True),
default=lambda: datetime.now(timezone.utc),
nullable=False,
)
+
+
+class Conversation(Base):
+ __tablename__ = "conversations"
+
+ id: Mapped[str] = mapped_column(String(64), primary_key=True)
+ user_id: Mapped[int] = mapped_column(Integer, nullable=False, index=True)
+ title: Mapped[str] = mapped_column(String(255), nullable=False, default="New chat")
+ created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc), nullable=False)
+ updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc), nullable=False)
+
+
+class ChatMessage(Base):
+ __tablename__ = "chat_messages"
+
+ id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+ conversation_id: Mapped[str] = mapped_column(String(64), nullable=False, index=True)
+ role: Mapped[str] = mapped_column(String(20), nullable=False)
+ content: Mapped[str] = mapped_column(Text, nullable=False)
+ created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc), nullable=False)
+
+
+
+
+class Server(Base):
+ __tablename__ = "servers"
+
+ id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+ owner_id: Mapped[int] = mapped_column(ForeignKey("users.id", ondelete="CASCADE"), index=True, nullable=False)
+ hostname: Mapped[str] = mapped_column(String(255), nullable=False)
+ ip_address: Mapped[Optional[str]] = mapped_column(String(64), nullable=True)
+ os_info: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
+ cpu_cores: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
+ total_ram_gb: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ check_interval_seconds: Mapped[int] = mapped_column(Integer, default=60, nullable=False)
+ collector_token_hash: Mapped[Optional[str]] = mapped_column(String(64), nullable=True, unique=True)
+ # Stable host identity reported by self-enrolling collectors, so a reinstall maps back to the same server.
+ machine_id: Mapped[Optional[str]] = mapped_column(String(64), nullable=True, index=True)
+ last_seen_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True), nullable=True)
+ created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc), nullable=False)
+
+
+class PendingCollector(Base):
+ """A collector that asked to join and is waiting for a user to Add or Dismiss it."""
+
+ __tablename__ = "pending_collectors"
+
+ id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+ # Hash of the secret the collector polls with; only that collector can pick up its token.
+ poll_secret_hash: Mapped[str] = mapped_column(String(64), unique=True, nullable=False)
+ pairing_code: Mapped[str] = mapped_column(String(16), nullable=False)
+ hostname: Mapped[str] = mapped_column(String(255), nullable=False)
+ machine_id: Mapped[Optional[str]] = mapped_column(String(64), nullable=True, index=True)
+ ip_address: Mapped[Optional[str]] = mapped_column(String(64), nullable=True)
+ os_info: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
+ status: Mapped[str] = mapped_column(String(16), default="pending", nullable=False) # pending | dismissed | approved
+ approved_server_id: Mapped[Optional[int]] = mapped_column(ForeignKey("servers.id", ondelete="CASCADE"), nullable=True)
+ created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc), nullable=False)
+ last_poll_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc), nullable=False)
+
+
+class EnrollmentKey(Base):
+ __tablename__ = "enrollment_keys"
+
+ id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+ owner_id: Mapped[int] = mapped_column(ForeignKey("users.id", ondelete="CASCADE"), unique=True, nullable=False)
+ key_hash: Mapped[str] = mapped_column(String(64), unique=True, nullable=False)
+ created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc), nullable=False)
+
+
+class HostMetric(Base):
+ __tablename__ = "host_metrics"
+
+ id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+ server_id: Mapped[int] = mapped_column(ForeignKey("servers.id", ondelete="CASCADE"), index=True, nullable=False)
+ time: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc), index=True, nullable=False)
+ cpu_utilization_pct: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ load_1m: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ load_5m: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ load_15m: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ ram_used_gb: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ ram_available_gb: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ ram_pct: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ swap_pct: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ disk_usage_pct: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ disk_inodes_pct: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ net_bytes_sent_mb: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ net_bytes_recv_mb: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ system_uptime_seconds: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+
+
+class ContainerMetric(Base):
+ __tablename__ = "container_metrics"
+
+ id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+ server_id: Mapped[int] = mapped_column(ForeignKey("servers.id", ondelete="CASCADE"), index=True, nullable=False)
+ container_id: Mapped[str] = mapped_column(String(128), index=True, nullable=False)
+ name: Mapped[str] = mapped_column(String(255), nullable=False)
+ image: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
+ status: Mapped[str] = mapped_column(String(64), nullable=False)
+ restart_count: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
+ cpu_pct: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ memory_used_mb: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ memory_pct: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ memory_limit_mb: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ net_rx_mb: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ net_tx_mb: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ block_read_mb: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ block_write_mb: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+ pids: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
+ started_at: Mapped[Optional[str]] = mapped_column(String(64), nullable=True)
+ ports: Mapped[Optional[str]] = mapped_column(String(512), nullable=True)
+ healthcheck_status: Mapped[Optional[str]] = mapped_column(String(64), nullable=True)
+ time: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc), index=True, nullable=False)
+
+
+class IncidentAlert(Base):
+ __tablename__ = "incident_alerts"
+
+ id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+ server_id: Mapped[int] = mapped_column(ForeignKey("servers.id", ondelete="CASCADE"), index=True, nullable=False)
+ severity: Mapped[str] = mapped_column(String(16), default="WARNING", nullable=False)
+ title: Mapped[str] = mapped_column(String(255), nullable=False)
+ description: Mapped[str] = mapped_column(Text, nullable=False)
+ status: Mapped[str] = mapped_column(String(32), default="active", nullable=False)
+ created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc), index=True, nullable=False)
diff --git a/src/backend/rate_limit.py b/src/backend/rate_limit.py
index a929698..8e96942 100644
--- a/src/backend/rate_limit.py
+++ b/src/backend/rate_limit.py
@@ -43,6 +43,12 @@ def enforce_register_limit(redis_client, *, ip_address: str, limit: int, window_
return key
+def enforce_ip_limit(redis_client, *, scope: str, ip_address: str, limit: int, window_seconds: int) -> str:
+ key = _key(scope, ip_address)
+ _record_attempt(redis_client, key, limit, window_seconds)
+ return key
+
+
def reset_limits(redis_client, *keys: str) -> None:
try:
redis_client.delete(*keys)
diff --git a/src/backend/seed_user.py b/src/backend/seed_user.py
new file mode 100644
index 0000000..f14d387
--- /dev/null
+++ b/src/backend/seed_user.py
@@ -0,0 +1,58 @@
+import os
+import sys
+
+# Dodaj roditeljski direktorij (src/) u Python path kako bi 'backend' postao dostupan paket
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from passlib.context import CryptContext
+
+# Sada uvozi preko backend paketa (što rješava .config u db.py)
+from backend.db import SessionLocal
+from backend.models import User
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+
+def create_initial_user():
+ email = "[email protected]"
+ raw_password = "adminspass123"
+ name = "Admin User"
+ role = "admin"
+
+ db = SessionLocal()
+ try:
+ existing_user = db.query(User).filter(User.email == email).first()
+ if existing_user:
+ print(f"⚠️ Korisnik s emailom '{email}' već postoji u bazi!")
+ return
+
+ hashed_password = pwd_context.hash(raw_password)
+
+ new_user = User(
+ email=email,
+ name=name,
+ password_hash=hashed_password,
+ role=role,
+ is_active=True,
+ )
+
+ db.add(new_user)
+ db.commit()
+ db.refresh(new_user)
+
+ print("--------------------------------------------------")
+ print("✅ Korisnik je uspješno dodan u bazu!")
+ print(f" ID: {new_user.id}")
+ print(f" Email: {new_user.email}")
+ print(f" Lozinka: {raw_password}")
+ print("--------------------------------------------------")
+
+ except Exception as e:
+ db.rollback()
+ print(f"❌ Greška: {e}")
+ finally:
+ db.close()
+
+
+if __name__ == "__main__":
+ create_initial_user()
\ No newline at end of file