Add registration toggle and password change; genericise deploy

Two things the running instance needed.

**Registration toggle.** Admin -> General, backed by a new settings table
group rather than the environment. LEMBAS_ALLOW_SIGNUP now seeds only the
initial value: once an administrator saves the setting, the stored value
wins. The alternative -- environment always winning -- means a toggle in
the UI silently reverts on the next restart, which is worse than not
offering one. Closing registration also removes the "Create one" link
from the sign-in page, so the link never leads somewhere that refuses.

**Password change**, on the user settings page. Changing a password
revokes every other session and immediately re-issues a cookie for the
current one: if the reason for the change is that somebody else knows
the password, leaving their session alive defeats the point, but signing
the user out of the tab they are standing in is merely rude.

**deploy/ is now host-agnostic.** This repository is public, so the unit
and vhost became templates with __PREFIX__ / __SITE_HOST__ / __APP_PORT__
substituted at install time, and every path, hostname and port moved to
environment variables. REPO_URL defaults to the checkout's own origin so
a fork deploys itself. Machine-specific values belong in private notes,
not here -- CLAUDE.md now says so.

83 tests, ruff clean.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

src/lembas/api/admin.py

@@ -11,7 +11,8 @@ from sqlalchemy import func, select
 from sqlalchemy.orm import Session as DBSession
 
 from lembas.api.deps import AdminUser, Db
-from lembas.db.models import Connection, Model
+from lembas.db.models import Connection, Model, User
+from lembas.services import settings_store
 from lembas.services.crypto import decrypt, encrypt, mask
 from lembas.services.llm.openai_client import Endpoint, LLMError, list_models
 from lembas.web.templating import render
@@ -39,7 +40,43 @@ def _connections(db: DBSession) -> list[Connection]:
 
 @router.get("")
 async def admin_home(user: AdminUser):
-    return RedirectResponse("/admin/connections", status_code=status.HTTP_303_SEE_OTHER)
+    return RedirectResponse("/admin/general", status_code=status.HTTP_303_SEE_OTHER)
+
+
+@router.get("/general")
+async def general_page(request: Request, db: Db, user: AdminUser, saved: bool = False):
+    return render(
+        request,
+        "admin/general.html",
+        {
+            "values": settings_store.get_group(db),
+            "saved": saved,
+            "user_count": db.scalar(select(func.count()).select_from(User)),
+        },
+    )
+
+
+@router.post("/general")
+async def save_general(
+    db: Db,
+    user: AdminUser,
+    instance_name: str = Form("LLeMbas"),
+    allow_signup: bool = Form(False),
+) -> Response:
+    """Save instance settings.
+
+    Unchecked checkboxes are simply absent from a form post, which is why
+    allow_signup defaults to False here -- that absence *is* the "off" signal.
+    """
+    settings_store.update(
+        db,
+        {
+            "instance_name": instance_name.strip()[:120] or "LLeMbas",
+            "allow_signup": allow_signup,
+        },
+    )
+    log.info("registration %s by %s", "opened" if allow_signup else "closed", user.email)
+    return RedirectResponse("/admin/general?saved=1", status_code=status.HTTP_303_SEE_OTHER)
 
 
 @router.get("/connections")

src/lembas/api/auth.py

@@ -13,6 +13,7 @@ from lembas.config import settings
 from lembas.db.models import ROLE_ADMIN, ROLE_USER, User
 from lembas.security.passwords import hash_password, validate_password, verify_password
 from lembas.security.sessions import COOKIE_NAME, create_session, revoke_session
+from lembas.services import settings_store
 from lembas.web.templating import render
 
 log = logging.getLogger(__name__)
@@ -48,6 +49,19 @@ def _safe_next(raw: str | None) -> str:
     return raw
 
 
+def _login_page(request: Request, db: Db, *, status_code: int = 200, **context):
+    """Render the sign-in page.
+
+    Always goes through here so `allow_signup` reflects the *stored* setting
+    rather than the environment default baked in by render(). Otherwise the
+    "Create one" link would keep appearing after an administrator closed
+    registration, offering a link that only leads to a refusal.
+    """
+    context.setdefault("next", "/")
+    context["allow_signup"] = settings_store.signup_allowed(db)
+    return render(request, "auth/login.html", context, status_code=status_code)
+
+
 @router.get("/login")
 async def login_form(request: Request, db: Db, user: CurrentUser, next: str = "/"):
     if user is not None:
@@ -57,7 +71,7 @@ async def login_form(request: Request, db: Db, user: CurrentUser, next: str = "/
     # cannot possibly satisfy.
     if _no_users_yet(db):
         return RedirectResponse("/auth/register", status_code=status.HTTP_303_SEE_OTHER)
-    return render(request, "auth/login.html", {"next": _safe_next(next)})
+    return _login_page(request, db, next=_safe_next(next))
 
 
 @router.post("/login")
@@ -75,21 +89,23 @@ async def login(
     # cannot be used to discover which addresses are registered.
     if user is None or not verify_password(password, user.password_hash):
         log.info("failed sign-in for %s", email)
-        return render(
+        return _login_page(
             request,
-            "auth/login.html",
-            {"error": "That email and password do not match.", "email": email,
-             "next": _safe_next(next)},
+            db,
             status_code=status.HTTP_401_UNAUTHORIZED,
+            error="That email and password do not match.",
+            email=email,
+            next=_safe_next(next),
         )
 
     if not user.active:
-        return render(
+        return _login_page(
             request,
-            "auth/login.html",
-            {"error": "This account has been deactivated. Ask an administrator.",
-             "email": email, "next": _safe_next(next)},
+            db,
             status_code=status.HTTP_403_FORBIDDEN,
+            error="This account has been deactivated. Ask an administrator.",
+            email=email,
+            next=_safe_next(next),
         )
 
     token = create_session(
@@ -108,12 +124,12 @@ async def register_form(request: Request, db: Db, user: CurrentUser):
     if user is not None:
         return RedirectResponse("/", status_code=status.HTTP_303_SEE_OTHER)
     first_run = _no_users_yet(db)
-    if not first_run and not settings.allow_signup:
-        return render(
+    if not first_run and not settings_store.signup_allowed(db):
+        return _login_page(
             request,
-            "auth/login.html",
-            {"error": "Registration is closed. Ask an administrator for an account."},
+            db,
             status_code=status.HTTP_403_FORBIDDEN,
+            error="Registration is closed. Ask an administrator for an account.",
         )
     return render(request, "auth/register.html", {"first_run": first_run})
 
@@ -127,12 +143,12 @@ async def register(
     password: str = Form(...),
 ):
     first_run = _no_users_yet(db)
-    if not first_run and not settings.allow_signup:
-        return render(
+    if not first_run and not settings_store.signup_allowed(db):
+        return _login_page(
             request,
-            "auth/login.html",
-            {"error": "Registration is closed. Ask an administrator for an account."},
+            db,
             status_code=status.HTTP_403_FORBIDDEN,
+            error="Registration is closed. Ask an administrator for an account.",
         )
 
     name = name.strip()

src/lembas/api/pages.py

@@ -97,13 +97,23 @@ async def chat_detail(request: Request, db: Db, user: RequiredUser, chat_id: str
 
 
 @router.get("/settings")
-async def settings_page(request: Request, db: Db, user: RequiredUser):
+async def settings_page(
+    request: Request,
+    db: Db,
+    user: RequiredUser,
+    error: str = "",
+    saved: str = "",
+):
+    # error/saved arrive as query parameters because the password form redirects
+    # back here: a POST that re-rendered in place would re-submit on refresh.
     return render(
         request,
         "settings.html",
         {
             "chat": None,
             "models": chat_service.available_models(db),
+            "error": error,
+            "saved": saved,
             **_sidebar_context(db, user),
         },
     )

src/lembas/api/preferences.py

@@ -2,9 +2,17 @@
 
 from __future__ import annotations
 
-from fastapi import APIRouter, Body
+import logging
+
+from fastapi import APIRouter, Body, Form, Request, status
+from fastapi.responses import RedirectResponse, Response
 
 from lembas.api.deps import Db, RequiredUser
+from lembas.config import settings
+from lembas.security.passwords import hash_password, validate_password, verify_password
+from lembas.security.sessions import COOKIE_NAME, create_session, revoke_all_for_user
+
+log = logging.getLogger(__name__)
 
 router = APIRouter(prefix="/api/preferences", tags=["preferences"])
 
@@ -27,3 +35,68 @@ async def set_theme(db: Db, user: RequiredUser, theme: str = Body(..., embed=Tru
     user.settings_json = {**(user.settings_json or {}), "theme": theme}
     db.commit()
     return {"ok": True, "theme": theme}
+
+
+@router.post("/password")
+async def change_password(
+    request: Request,
+    db: Db,
+    user: RequiredUser,
+    current_password: str = Form(...),
+    new_password: str = Form(...),
+    confirm_password: str = Form(...),
+) -> Response:
+    """Change your own password.
+
+    Every other session is revoked on success. If the reason for changing a
+    password is that someone else knows it, leaving their session alive would
+    defeat the point.
+    """
+
+    def back(message: str, ok: bool = False) -> Response:
+        from urllib.parse import quote
+
+        field = "saved" if ok else "error"
+        return RedirectResponse(
+            f"/settings?{field}={quote(message)}", status_code=status.HTTP_303_SEE_OTHER
+        )
+
+    if not verify_password(current_password, user.password_hash):
+        log.info("failed password change for %s: current password wrong", user.email)
+        return back("Your current password is not correct.")
+
+    if new_password != confirm_password:
+        return back("The new passwords do not match.")
+
+    if (problem := validate_password(new_password)) is not None:
+        return back(problem)
+
+    if verify_password(new_password, user.password_hash):
+        return back("That is already your password.")
+
+    user.password_hash = hash_password(new_password)
+    db.commit()
+
+    revoke_all_for_user(db, user)
+    token = create_session(
+        db,
+        user,
+        user_agent=request.headers.get("user-agent", ""),
+        ip_address=request.client.host if request.client else "",
+    )
+    log.info("password changed for %s; other sessions revoked", user.email)
+
+    # revoke_all_for_user killed this session too, so hand back a fresh cookie
+    # -- otherwise changing your password would sign you out of the tab you are
+    # standing in.
+    response = back("Password changed. Any other sessions have been signed out.", ok=True)
+    response.set_cookie(
+        COOKIE_NAME,
+        token,
+        max_age=settings.session_ttl,
+        httponly=True,
+        samesite="lax",
+        secure=False,
+        path="/",
+    )
+    return response