b4n1 0.0.2__py3-none-any.whl

b4n1/__init__.py

@@ -0,0 +1,133 @@
+"""
+b4n1-fast Python SDK — Write Python, Run Rust
+Complete web framework with ORM, validation, middleware, admin, swagger, PWA,
+queue, auth, email, config, API keys, and native database (b4n1-db).
+"""
+
+from b4n1.app import App, Request, Router
+from b4n1.models import Model, QuerySet
+from b4n1.responses import JsonResponse
+from b4n1.validation import ValidationError, validate_email, validate_password
+from b4n1.admin import (
+    AdminSite, AdminConfig, register_admin_routes,
+    register_module, render_sidebar_html, get_modules, clear_modules,
+    inject_edit_toolbar, register_edit_api,
+)
+from b4n1.swagger import SwaggerGenerator, RouteInfo
+from b4n1.pwa import PwaManifest, ServiceWorker, generate_pwa_html
+from b4n1.templates import (
+    ReactiveTemplateEngine,
+    render_template,
+    render_string,
+    render_window,
+    render_window_str,
+    send_html,
+    send_redirect,
+)
+from b4n1.queue import B4N1Queue, Task, Worker, Scheduler, TaskBroker
+from b4n1.queue_admin import QueueAdminPanel
+from b4n1.auth import (
+    ROLES,
+    User,
+    AuthBackend,
+    hash_password,
+    verify_password,
+    init_role_system,
+    set_user_role,
+    is_admin,
+    is_superadmin,
+    create_session,
+    get_user_from_session,
+    get_session_cookie,
+    require_auth,
+    require_admin,
+    require_superadmin,
+    log_login,
+    get_client_ip,
+    create_superuser,
+)
+
+from b4n1.db import NativeBackend, SQLiteAdapter, get_db, _QueryResult
+from b4n1.config import Settings, settings
+from b4n1.mail import (
+    send_email,
+    generate_verification_email,
+    generate_reset_email,
+)
+from b4n1.api_keys import (
+    generate_key,
+    list_keys,
+    create_key,
+    revoke_key,
+    update_fingerprint,
+    lookup_key,
+    MAX_KEYS_PER_USER,
+)
+from b4n1.image_gen import generate_image, register_image_api
+from b4n1.rate_limiter import SlidingWindowRateLimiter, RateLimitMiddleware
+from b4n1.middleware import (
+    native_dumps,
+    native_loads,
+    DjangoNativeMiddleware,
+    FlaskNativeMiddleware,
+    FastAPINativeMiddleware,
+)
+
+__all__ = [
+    "App",
+    "Request",
+    "Router",
+    "Model",
+    "QuerySet",
+    "JsonResponse",
+    "ValidationError",
+    "validate_email",
+    "validate_password",
+    "AdminSite",
+    "AdminConfig",
+    "register_module",
+    "render_sidebar_html",
+    "get_modules",
+    "clear_modules",
+    "inject_edit_toolbar",
+    "register_edit_api",
+    "SwaggerGenerator",
+    "RouteInfo",
+    "PwaManifest",
+    "ServiceWorker",
+    "generate_pwa_html",
+    "ReactiveTemplateEngine",
+    "B4N1Queue",
+    "Task",
+    "Worker",
+    "Scheduler",
+    "TaskBroker",
+    "QueueAdminPanel",
+    "AuthBackend",
+    "User",
+    "NativeBackend",
+    "SQLiteAdapter",
+    "get_db",
+    "_QueryResult",
+    "Settings",
+    "settings",
+    "send_email",
+    "generate_verification_email",
+    "generate_reset_email",
+    "generate_key",
+    "list_keys",
+    "create_key",
+    "revoke_key",
+    "update_fingerprint",
+    "lookup_key",
+    "MAX_KEYS_PER_USER",
+    "generate_image",
+    "register_image_api",
+    "SlidingWindowRateLimiter",
+    "RateLimitMiddleware",
+    "native_dumps",
+    "native_loads",
+    "DjangoNativeMiddleware",
+    "FlaskNativeMiddleware",
+    "FastAPINativeMiddleware",
+]

b4n1/admin/__init__.py

@@ -0,0 +1,11 @@
+from b4n1.admin.site import AdminConfig, AdminSite
+from b4n1.admin.views import register_admin_routes
+from b4n1.admin.menu import register_module, render_sidebar_html, get_modules, clear_modules
+from b4n1.admin.inline_edit import inject_edit_toolbar, register_edit_api
+
+__all__ = [
+    "AdminConfig", "AdminSite",
+    "register_admin_routes",
+    "register_module", "render_sidebar_html", "get_modules", "clear_modules",
+    "inject_edit_toolbar", "register_edit_api",
+]

b4n1/admin/inline_edit.py

@@ -0,0 +1,82 @@
+"""Inline Visual Editor — admin edit-in-place on public pages.
+
+Usage:
+  1. Add `data-edit` + `data-field` + `data-type` to any DOM element
+  2. Call `inject_edit_toolbar(html, user)` in your page render
+  3. Register save handlers with `register_edit_api(app, save_callback)`
+"""
+
+INLINE_CSS = """
+.editable{position:relative;cursor:pointer;transition:outline .2s}
+.editable:hover{outline:2px dashed #16a34a;outline-offset:2px}
+.editable[data-type=image]:hover::after{content:'\\270F\\FE0F';position:absolute;top:4px;right:4px;background:#16a34a;color:#fff;border-radius:4px;padding:2px 6px;font-size:12px;z-index:10;line-height:1.4}
+.editable[data-type=text]:hover::after{content:'\\270F\\FE0F';position:absolute;top:-8px;right:-8px;background:#16a34a;color:#fff;border-radius:50%;width:20px;height:20px;display:flex;align-items:center;justify-content:center;font-size:10px;z-index:10}
+"""
+
+INLINE_JS = """
+(function(){
+if(window.__b4n1_inline_editor)return;window.__b4n1_inline_editor=true;
+var s=document.createElement('style');
+s.textContent=INLINE_CSS_PLACEHOLDER;
+document.head.appendChild(s);
+document.querySelectorAll('[data-edit]').forEach(function(el){
+el.classList.add('editable');
+el.addEventListener('click',function(e){
+e.preventDefault();e.stopPropagation();
+var type=this.dataset.type||'text';
+var field=this.dataset.field||'';
+var val=type==='image'?this.src:this.textContent;
+var p=prompt('Editar '+field+':',val);
+if(p&&p!==val){
+if(type==='image')this.src=p;
+else this.textContent=p;
+var fd=new FormData();
+fd.append('field',field);
+fd.append('value',p);
+fetch('/api/admin/edit',{method:'POST',body:fd});
+}
+});
+});
+})();
+"""
+
+
+def inject_edit_toolbar(html: str, user: dict | None) -> str:
+    if not user:
+        return html
+    role = user.get("role", "")
+    if role not in ("admin", "superadmin"):
+        return html
+    script = INLINE_JS.replace("INLINE_CSS_PLACEHOLDER", INLINE_CSS.replace("'", "\\'").replace("\n", " "))
+    return html.replace("</body>", f"<script>{script}</script>\n</body>")
+
+
+def register_edit_api(app, save_callback):
+    """Register the /api/admin/edit endpoint.
+
+    save_callback(field: str, value: str) -> None is called on each edit.
+    """
+    import json
+
+    @app.post("/api/admin/edit")
+    def _inline_edit_handler(handler, body, **kw):
+        try:
+            if body and body.startswith("{"):
+                data = json.loads(body)
+            else:
+                import urllib.parse
+                data = urllib.parse.parse_qs(body)
+                data = {k: v[0] if isinstance(v, list) and len(v) == 1 else v for k, v in data.items()}
+            field = data.get("field", "")
+            value = data.get("value", "")
+            if field:
+                save_callback(field, value)
+            handler.send_response(200)
+            handler.send_header("Content-Type", "application/json")
+            handler.end_headers()
+            handler.wfile.write(b'{"ok":true}')
+        except Exception as e:
+            handler.send_response(500)
+            handler.end_headers()
+            handler.wfile.write(str(e).encode())
+        return None

b4n1/admin/menu.py

@@ -0,0 +1,34 @@
+"""Admin Super Menu — Drupal-like module system.
+
+Apps register their modules with icon, route, and order.
+"""
+
+_MODULES: list[dict] = []
+
+
+def register_module(name: str, icon: str, route: str, order: int = 50, badge: str = ""):
+    """Register a module in the admin sidebar menu."""
+    _MODULES.append(dict(name=name, icon=icon, route=route, order=order, badge=badge))
+    _MODULES.sort(key=lambda m: m["order"])
+
+
+def render_sidebar_html(current_route: str = "/admin") -> str:
+    items = ""
+    for m in _MODULES:
+        active = "active" if m["route"] == current_route else ""
+        badge_html = f'<span class="menu-badge">{m["badge"]}</span>' if m.get("badge") else ""
+        items += (
+            f'<a href="{m["route"]}" class="{active}">'
+            f'<span class="menu-icon">{m["icon"]}</span>'
+            f'<span class="menu-label">{m["name"]}</span>'
+            f'{badge_html}</a>'
+        )
+    return items
+
+
+def get_modules() -> list[dict]:
+    return list(_MODULES)
+
+
+def clear_modules():
+    _MODULES.clear()

b4n1/admin/site.py

@@ -0,0 +1,40 @@
+class AdminConfig:
+    def __init__(self, model_name):
+        self.model_name = model_name
+        self.list_display = []
+        self.search_fields = []
+        self.list_filter = []
+        self.ordering = None
+        self.list_per_page = 100
+
+    def with_list_display(self, fields):
+        self.list_display = list(fields)
+        return self
+
+    def with_search_fields(self, fields):
+        self.search_fields = list(fields)
+        return self
+
+    def with_list_filter(self, fields):
+        self.list_filter = list(fields)
+        return self
+
+    def with_ordering(self, field):
+        self.ordering = field
+        return self
+
+
+class AdminSite:
+    def __init__(self, title="B4N1-FAST Admin"):
+        self.title = title
+        self.configs = {}
+
+    def register(self, config):
+        self.configs[config.model_name] = config
+        return self
+
+    def generate_dashboard_url(self):
+        return "/admin/"
+
+    def generate_list_url(self, model_name):
+        return f"/admin/{model_name}/"

b4n1/admin/views.py

@@ -0,0 +1,280 @@
+"""Admin CRUD views: login, dashboard, user CRUD, API keys, telemetry, inline edit API."""
+
+import secrets, urllib.parse, json, time
+from b4n1.auth import (
+    ROLES, hash_password, verify_password, require_admin, require_superadmin,
+    create_session, get_session_cookie, get_user_from_session, log_login,
+    get_client_ip,
+)
+from b4n1.templates import render_window, send_html, send_redirect
+from b4n1.admin.menu import render_sidebar_html, register_module
+
+
+def _role_opt(selected_role):
+    return "".join(
+        f'<option value="{r}" {"selected" if r == selected_role else ""}>{r}</option>'
+        for r in ROLES
+    )
+
+
+def _user_rows(users):
+    rows = ""
+    for u in users:
+        role_cls = {
+            "superadmin": "bg-purple-600/30 text-purple-400",
+            "admin": "bg-red-600/30 text-red-400",
+            "staff": "bg-blue-600/30 text-blue-400",
+            "user": "bg-green-600/20 text-green-400",
+        }.get(u.get("role", "user"), "bg-gray-600/20 text-gray-400")
+        status_text = "Active" if u.get("is_active") else "Inactive"
+        st_cls = "text-green-400" if u.get("is_active") else "text-red-400"
+        uid = u["id"]
+        uname = u["username"]
+        email = u.get("email") or "-"
+        role_val = u.get("role") or "user"
+        rows += ("<tr class='border-b border-white/5 hover:bg-white/5'>"
+            + f"<td class='py-3 px-4 text-sm'>{uid}</td>"
+            + f"<td class='py-3 px-4 text-sm font-medium'>{uname}</td>"
+            + f"<td class='py-3 px-4 text-sm text-gray-400'>{email}</td>"
+            + f"<td class='py-3 px-4'><span class='text-[10px] px-2 py-0.5 rounded-full border {role_cls}'>{role_val}</span></td>"
+            + f"<td class='py-3 px-4 text-sm {st_cls}'>{status_text}</td>"
+            + f"<td class='py-3 px-4 text-right'>"
+            + f"<button hx-get='/admin/users/edit/{uid}' hx-target='#desktop' hx-swap='beforeend' class='text-blue-400 hover:text-blue-300 text-xs font-medium cursor-pointer'>Edit</button>"
+            + f"<button hx-delete='/admin/users/{uid}' hx-confirm='Delete {uname}?' hx-target='closest tr' hx-swap='delete' class='text-red-400 hover:text-red-300 text-xs font-medium ml-2'>Delete</button>"
+            + "</td></tr>")
+    return rows
+
+
+def _api_key_rows(db):
+    rows = db.execute(
+        "SELECT ak.id, ak.user_id, ak.key, ak.name, ak.is_active, "
+        "ak.created_at, u.username "
+        "FROM api_keys ak JOIN users u ON ak.user_id = u.id ORDER BY ak.created_at DESC"
+    ).fetchall()
+    html = ""
+    for r in rows:
+        sc = "text-green-400" if r["is_active"] else "text-red-400"
+        ks = r["key"][:12] + "..." if len(r["key"]) > 15 else r["key"]
+        html += (
+            f"<tr class='border-b border-white/5 hover:bg-white/5'>"
+            f"<td class='py-2 px-3 text-xs text-gray-400'>{r['id']}</td>"
+            f"<td class='py-2 px-3 text-xs'>{r['username']}</td>"
+            f"<td class='py-2 px-3 text-xs font-mono text-gray-300'>{ks}</td>"
+            f"<td class='py-2 px-3 text-xs text-gray-400'>{r.get('name') or '-'}</td>"
+            f"<td class='py-2 px-3 text-xs {sc}'>{'Active' if r['is_active'] else 'Inactive'}</td></tr>"
+        )
+    return html, len(rows)
+
+
+def _r(ctx=None):
+    return str(secrets.randbits(32))
+
+
+_LOGIN_HTML = """<!DOCTYPE html>
+<html lang="es"><head>
+<meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1.0">
+<title>Ingresar — B4N1-FAST Admin</title>
+<script src="https://cdn.tailwindcss.com"></script>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+<style>
+*{margin:0;padding:0;box-sizing:border-box}
+body{font-family:'Inter',sans-serif;background:#0f172a;color:#e2e8f0;min-height:100vh;display:flex;align-items:center;justify-content:center}
+.login-card{background:#1e293b;border-radius:16px;padding:40px;width:400px;border:1px solid #334155;box-shadow:0 25px 50px -12px rgba(0,0,0,.5)}
+.login-card h1{font-size:1.5rem;font-weight:700;margin-bottom:4px}
+.login-card p{color:#64748b;font-size:.9rem;margin-bottom:24px}
+.form-group{margin-bottom:16px}
+.form-group label{display:block;font-size:.8rem;font-weight:600;color:#94a3b8;margin-bottom:6px;text-transform:uppercase;letter-spacing:.5px}
+.form-group input{width:100%;padding:10px 14px;background:#0f172a;border:1px solid #334155;border-radius:8px;color:#e2e8f0;font-size:.9rem;outline:none;transition:border .2s}
+.form-group input:focus{border-color:#16a34a}
+.btn-login{width:100%;padding:12px;background:#16a34a;color:#fff;border:none;border-radius:8px;font-size:.95rem;font-weight:600;cursor:pointer;transition:background .2s}
+.btn-login:hover{background:#15803d}
+.error{background:#7f1d1d;color:#fca5a5;padding:10px 14px;border-radius:8px;font-size:.85rem;margin-bottom:16px;border:1px solid #991b1b}
+.footer{text-align:center;margin-top:20px;font-size:.8rem;color:#475569}
+</style></head><body>
+<div class="login-card">
+<h1>🔐 Ingresar</h1>
+<p>Administración B4N1-FAST</p>
+{ERROR_BLOCK}
+<form method="post" action="{LOGIN_ACTION}">
+<div class="form-group"><label>Usuario</label><input type="text" name="username" required autofocus></div>
+<div class="form-group"><label>Contraseña</label><input type="password" name="password" required></div>
+<button type="submit" class="btn-login">Ingresar</button>
+</form>
+<div class="footer">B4N1-FAST v1.0</div>
+</div></body></html>"""
+
+
+def _login_page_html(error="", login_route="/login"):
+    err = f'<div class="error">{error}</div>' if error else ""
+    return _LOGIN_HTML.replace("{ERROR_BLOCK}", err).replace("{LOGIN_ACTION}", login_route)
+
+
+def register_admin_routes(app, login_route="/login", logout_route="/logout"):
+    register_module("Dashboard", "📊", "/admin", order=10)
+    register_module("Usuarios", "👥", "/admin", order=20)
+    register_module("API Keys", "🔑", "/api-keys", order=80)
+
+    @app.get(login_route)
+    def login_get(h, body):
+        return send_html(h, _login_page_html(login_route=login_route))
+
+    @app.post(login_route)
+    def login_post(h, body):
+        data = urllib.parse.parse_qs(body)
+        uname = data.get("username", [""])[0]
+        pw = data.get("password", [""])[0]
+        db = app._db
+        user = db.execute(
+            "SELECT * FROM users WHERE username=? AND is_active=1", (uname,)
+        ).fetchone()
+        if not user or not verify_password(pw, user["password_hash"]):
+            log_login(0, uname, get_client_ip(h), h.headers.get("User-Agent", ""), success=False)
+            return send_html(h, _login_page_html("Usuario o contraseña incorrectos", login_route))
+        log_login(user["id"], uname, get_client_ip(h), h.headers.get("User-Agent", ""), success=True)
+        key = create_session(user["id"], get_client_ip(h), h.headers.get("User-Agent", ""))
+        h.send_response(302)
+        h.send_header("Set-Cookie", f"sessionid={key}; Path=/; HttpOnly; SameSite=Lax; Max-Age=86400")
+        h.send_header("Location", "/admin")
+        h.send_header("Content-Length", "0")
+        h.end_headers()
+        return None
+
+    @app.get(logout_route)
+    def logout_get(h, body):
+        cookie = get_session_cookie(h.headers)
+        if cookie:
+            db = app._db
+            db.execute("DELETE FROM sessions WHERE session_key=?", (cookie,))
+        h.send_response(302)
+        h.send_header("Set-Cookie", "sessionid=; Path=/; HttpOnly; Max-Age=0")
+        h.send_header("Location", login_route)
+        h.send_header("Content-Length", "0")
+        h.end_headers()
+        return None
+
+    @app.get("/admin")
+    @require_admin
+    def admin_dashboard(h, body, user):
+        db = app._db
+        t = db.execute("SELECT COUNT(*) as c FROM users").fetchone()["c"]
+        a = db.execute("SELECT COUNT(*) as c FROM users WHERE is_active = 1").fetchone()["c"]
+        ac = db.execute("SELECT COUNT(*) as c FROM users WHERE role IN ('superadmin','admin')").fetchone()["c"]
+        sc = db.execute("SELECT COUNT(*) as c FROM users WHERE role = 'staff'").fetchone()["c"]
+        l24 = db.execute("SELECT COUNT(*) as c FROM login_logs WHERE created_at > datetime('now','-24 hours') AND success=1").fetchone()["c"]
+        f24 = db.execute("SELECT COUNT(*) as c FROM login_logs WHERE created_at > datetime('now','-24 hours') AND success=0").fetchone()["c"]
+        r24 = db.execute("SELECT COUNT(*) as c FROM users WHERE created_at > datetime('now','-24 hours')").fetchone()["c"]
+        recent = db.execute("SELECT username,ip_address,success,created_at FROM login_logs ORDER BY created_at DESC LIMIT 20").fetchall()
+        users = db.execute("SELECT id,username,email,role,is_active FROM users ORDER BY created_at DESC").fetchall()
+        rh = "".join(
+            f"<tr class='text-[10px] border-b border-white/5'>"
+            f"<td class='py-1 px-2'>{'🟢' if r['success'] else '🔴'}</td>"
+            f"<td class='py-1 px-2'>{r.get('username') or '-'}</td>"
+            f"<td class='py-1 px-2 text-gray-400'>{r.get('ip_address') or '-'}</td>"
+            f"<td class='py-1 px-2 text-gray-500'>{r['created_at']}</td></tr>"
+            for r in recent
+        )
+        sidebar = render_sidebar_html("/admin")
+        ctx = dict(total_users=t, active_users=a, admin_users=ac, staff_users=sc,
+                   logins_24h=l24, failed_24h=f24, registrations_24h=r24,
+                   recent_logins=rh, users_rows=_user_rows(users),
+                   sidebar=sidebar, random=_r(), user=user)
+        return render_window(h, "admin", "Admin Dashboard", "fa-shield-halved",
+                             "admin/dashboard.html", ctx, "900px", "600px")
+
+    @app.get("/admin/users/create")
+    @require_superadmin
+    def admin_create_user_get(h, body, user):
+        return render_window(h, "admin-create-user", "Create User", "fa-user-plus",
+                             "admin/create_user.html", dict(random=_r(), user=user, sidebar=render_sidebar_html()), "450px", "500px")
+
+    @app.post("/admin/users/create")
+    @require_superadmin
+    def admin_create_user_post(h, body, user):
+        data = urllib.parse.parse_qs(body)
+        uname = data.get("username", [""])[0]
+        email = data.get("email", [""])[0]
+        pw = data.get("password", [""])[0]
+        role = data.get("role", ["user"])[0]
+        if not uname or not email or not pw:
+            return render_window(h, "admin-create-user", "Create User", "fa-user-plus",
+                                 "admin/create_user.html", dict(error="All fields required", random=_r(), user=user, sidebar=render_sidebar_html()), "450px", "500px")
+        db = app._db
+        if db.execute("SELECT id FROM users WHERE username=? OR email=?", (uname, email)).fetchone():
+            return render_window(h, "admin-create-user", "Create User", "fa-user-plus",
+                                 "admin/create_user.html", dict(error="Username or email exists", random=_r(), user=user, sidebar=render_sidebar_html()), "450px", "500px")
+        role = role if role in ROLES else "user"
+        db.execute(
+            "INSERT INTO users (username,email,password_hash,is_active,is_staff,is_superuser,role) VALUES (?,?,?,1,?,?,?)",
+            (uname, email, hash_password(pw), 1 if role in ("superadmin", "admin", "staff") else 0,
+             1 if role in ("superadmin", "admin") else 0, role)
+        )
+        new_id = db.execute("SELECT id FROM users WHERE username=?", (uname,)).fetchone()["id"]
+        db.execute("INSERT INTO api_keys (user_id,key,name) VALUES (?,?,'Default Key')",
+                   (new_id, f"b4n1_sk_{secrets.token_urlsafe(24)}"))
+        return send_redirect(h, "/admin")
+
+    @app.get("/admin/users/edit/{user_id}")
+    @require_admin
+    def admin_edit_user_get(h, body, user, user_id=None):
+        db = app._db
+        eu = db.execute("SELECT id,username,email,role,is_active FROM users WHERE id=?", (user_id,)).fetchone()
+        if not eu:
+            h.send_response(404); h.end_headers(); h.wfile.write(b"User not found"); return None
+        ctx = dict(user_id=eu["id"], username=eu["username"], email=eu.get("email") or "",
+                   role_options=_role_opt(eu.get("role") or "user"), is_active=eu["is_active"],
+                   random=_r(), user=user, sidebar=render_sidebar_html())
+        return render_window(h, "admin-edit-user", "Edit User", "fa-user-edit",
+                             "admin/edit_user.html", ctx, "450px", "450px")
+
+    @app.post("/admin/users/edit/{user_id}")
+    @require_admin
+    def admin_edit_user_post(h, body, user, user_id=None):
+        data = urllib.parse.parse_qs(body)
+        uname = data.get("username", [""])[0]
+        email = data.get("email", [""])[0]
+        role = data.get("role", [""])[0]
+        active = 1 if data.get("is_active", [""])[0] == "1" else 0
+        npw = data.get("new_password", [""])[0]
+        db = app._db
+        if role in ROLES:
+            db.execute(
+                "UPDATE users SET username=?,email=?,role=?,is_active=?,is_superuser=?,is_staff=? WHERE id=?",
+                (uname, email, role, active, 1 if role in ("superadmin", "admin") else 0,
+                 1 if role in ("superadmin", "admin", "staff") else 0, user_id)
+            )
+        else:
+            db.execute("UPDATE users SET username=?,email=?,is_active=? WHERE id=?", (uname, email, active, user_id))
+        if npw:
+            db.execute("UPDATE users SET password_hash=? WHERE id=?", (hash_password(npw), user_id))
+        return send_redirect(h, "/admin")
+
+    @app.delete("/admin/users/{user_id}")
+    @require_admin
+    def admin_delete_user(h, body, user, user_id=None):
+        if str(user["id"]) == str(user_id):
+            return {"status": "error", "message": "Cannot delete yourself"}
+        db = app._db
+        for tbl in ("sessions", "api_keys", "email_tokens", "password_resets"):
+            db.execute(f"DELETE FROM {tbl} WHERE user_id=?", (user_id,))
+        db.execute("DELETE FROM users WHERE id=?", (user_id,))
+        return {"status": "deleted"}
+
+    @app.get("/api-keys")
+    @require_admin
+    def admin_api_keys(h, body, user):
+        kh, total = _api_key_rows(app._db)
+        return render_window(h, "api-keys", "API Keys", "fa-key",
+                             "admin/api_keys.html", dict(rows=kh, total=total, random=_r(), user=user, sidebar=render_sidebar_html()), "800px", "450px")
+
+    @app.get("/api/admin/telemetry")
+    @require_admin
+    def admin_telemetry(h, body, user):
+        db = app._db
+        return dict(
+            total_users=db.execute("SELECT COUNT(*) as c FROM users").fetchone()["c"],
+            active_users=db.execute("SELECT COUNT(*) as c FROM users WHERE is_active=1").fetchone()["c"],
+            logins_24h=db.execute("SELECT COUNT(*) as c FROM login_logs WHERE created_at>datetime('now','-24 hours') AND success=1").fetchone()["c"],
+            failed_logins_24h=db.execute("SELECT COUNT(*) as c FROM login_logs WHERE created_at>datetime('now','-24 hours') AND success=0").fetchone()["c"],
+            registrations_7d=db.execute("SELECT COUNT(*) as c FROM users WHERE created_at>datetime('now','-7 days')").fetchone()["c"],
+            active_api_keys=db.execute("SELECT COUNT(*) as c FROM api_keys WHERE is_active=1").fetchone()["c"],
+        )