ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.
Python astracloudflarecontrol-panelcyberpaneldnsfablehosting-control-panelhosting-panelkimi-k3server-managementserverkitubuntu-web-panelwebserver
feat(databases): managed DB users and one-click Adminer SSO
Juan Denis76a688fb4937
diff --git a/backend/app/api/managed_db_users.py b/backend/app/api/managed_db_users.pynew file mode 100644index 00000000..efa7af29--- /dev/null+++ b/backend/app/api/managed_db_users.py@@ -0,0 +1,113 @@+"""Managed database users + one-click Adminer SSO.++Nested under a managed database id:+ GET /api/v1/managed-databases/<id>/users+ POST /api/v1/managed-databases/<id>/users+ DELETE /api/v1/managed-databases/<id>/users/<user_id>+ POST /api/v1/managed-databases/<id>/sso+"""+import logging++from flask import Blueprint, request, jsonify++from app.middleware.rbac import admin_required, developer_required+from app.services.managed_database_service import ManagedDatabaseService+from app.services.managed_db_user_service import ManagedDbUserService++logger = logging.getLogger(__name__)++managed_db_users_bp = Blueprint('managed_db_users', __name__)+++def _get_managed_or_404(managed_id):+ managed = ManagedDatabaseService.get(managed_id)+ if not managed:+ return None, (jsonify({'error': 'Managed database not found'}), 404)+ return managed, None+++@managed_db_users_bp.route('/<int:managed_id>/users', methods=['GET'])+@developer_required+def list_managed_db_users(managed_id):+ """Tracked users merged best-effort with the live engine list."""+ managed, err = _get_managed_or_404(managed_id)+ if err:+ return err+ users = ManagedDbUserService.list_users(managed)+ return jsonify({'users': users}), 200+++@managed_db_users_bp.route('/<int:managed_id>/users', methods=['POST'])+@admin_required+def create_managed_db_user(managed_id):+ """CREATE USER + GRANT scoped to this database. The password is returned+ exactly once in this response and never stored."""+ managed, err = _get_managed_or_404(managed_id)+ if err:+ return err+ data = request.get_json(silent=True) or {}+ result = ManagedDbUserService.create_user(+ managed,+ username=data.get('username'),+ password=data.get('password'),+ grants=data.get('grants'),+ )+ if 'error' in result:+ return jsonify({'error': result['error']}), 400+ return jsonify(result), 201+++@managed_db_users_bp.route('/<int:managed_id>/users/<int:user_id>', methods=['DELETE'])+@admin_required+def delete_managed_db_user(managed_id, user_id):+ """DROP USER in the engine and remove the tracking row."""+ from app.models.managed_database_user import ManagedDatabaseUser+ managed, err = _get_managed_or_404(managed_id)+ if err:+ return err+ row = ManagedDatabaseUser.query.filter_by(+ id=user_id, managed_database_id=managed.id).first()+ if not row:+ return jsonify({'error': 'User not found'}), 404+ result = ManagedDbUserService.delete_user(managed, row)+ if 'error' in result:+ return jsonify({'error': result['error']}), 400+ return jsonify({'success': True}), 200+++@managed_db_users_bp.route('/<int:managed_id>/sso', methods=['POST'])+@admin_required+def launch_managed_db_sso(managed_id):+ """Mint a 5-minute, single-database shadow credential and return the+ Adminer launch descriptor. The password crosses once, right here."""+ from app.middleware.rbac import get_current_user+ from app.services.db_admin_sso_service import DbAdminSsoService++ managed, err = _get_managed_or_404(managed_id)+ if err:+ return err++ user = get_current_user()+ descriptor = DbAdminSsoService.launch(+ managed, requested_by=getattr(user, 'id', None))+ if 'error' in descriptor:+ status = 400 if descriptor['error'] != 'Docker required' else 503+ return jsonify({'error': descriptor['error']}), status++ # Build the browser-reachable URL from the panel host the client used.+ panel_host = (request.host or 'localhost').rsplit(':', 1)[0]+ descriptor['url'] = f"http://{panel_host}:{descriptor['port']}"++ try:+ from app.services.audit_service import AuditService+ AuditService.log(+ action='db_sso_launch', user_id=getattr(user, 'id', None),+ target_type='managed_database', target_id=managed.id,+ details={'engine': managed.engine, 'name': managed.name,+ 'username': descriptor['username'],+ 'expires_at': descriptor['expires_at']},+ )+ except Exception as e: # pragma: no cover - audit is best-effort+ logger.debug('SSO audit log failed: %s', e)++ return jsonify(descriptor), 200diff --git a/backend/app/models/managed_database_user.py b/backend/app/models/managed_database_user.pynew file mode 100644index 00000000..7b697829--- /dev/null+++ b/backend/app/models/managed_database_user.py@@ -0,0 +1,77 @@+import json+from datetime import datetime++from app import db+++class ManagedDatabaseUser(db.Model):+ """A database user/grant ServerKit created on a managed database.++ Live engines forget nothing, but ServerKit used to: users created through+ the panel left no durable trace, so restarts lost the mapping between a+ managed database and the credentials provisioned for it. This row is that+ trace — it powers the users panel and scopes one-click admin SSO.++ ``is_shadow`` marks short-lived, single-use credentials (e.g. the Adminer+ SSO login) that a reaper drops once ``expires_at`` passes. Passwords are+ NEVER stored here — they cross the API exactly once at creation time.+ """++ __tablename__ = 'managed_database_users'++ id = db.Column(db.Integer, primary_key=True)+ managed_database_id = db.Column(+ db.Integer, db.ForeignKey('managed_databases.id', ondelete='CASCADE'),+ nullable=False, index=True,+ )+ username = db.Column(db.String(120), nullable=False)+ # JSON list of grant keywords, e.g. ["ALL"] or ["SELECT", "INSERT"].+ grants = db.Column(db.Text, nullable=False, default='["ALL"]')+ is_shadow = db.Column(db.Boolean, nullable=False, default=False)+ expires_at = db.Column(db.DateTime, nullable=True)+ created_at = db.Column(db.DateTime, default=datetime.utcnow)+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)++ # Deleting the managed database removes its user rows (ORM cascade); the+ # engine-side users are dropped explicitly by the service, never implicitly.+ managed_database = db.relationship(+ 'ManagedDatabase',+ backref=db.backref('users', cascade='all, delete-orphan'),+ )++ __table_args__ = (+ db.UniqueConstraint('managed_database_id', 'username',+ name='uq_managed_db_user'),+ )++ def get_grants(self):+ try:+ grants = json.loads(self.grants or '[]')+ return grants if isinstance(grants, list) else []+ except (ValueError, TypeError):+ return []++ def set_grants(self, grants):+ self.grants = json.dumps(list(grants or []))++ @property+ def is_expired(self):+ return bool(self.expires_at and self.expires_at < datetime.utcnow())++ def to_dict(self, live=None):+ data = {+ 'id': self.id,+ 'managed_database_id': self.managed_database_id,+ 'username': self.username,+ 'grants': self.get_grants(),+ 'is_shadow': self.is_shadow,+ 'expires_at': self.expires_at.isoformat() if self.expires_at else None,+ 'created_at': self.created_at.isoformat() if self.created_at else None,+ 'updated_at': self.updated_at.isoformat() if self.updated_at else None,+ }+ if live is not None:+ data['present'] = live.get('present')+ return data++ def __repr__(self):+ return f'<ManagedDatabaseUser {self.username} db={self.managed_database_id}>'diff --git a/backend/app/services/db_admin_sso_service.py b/backend/app/services/db_admin_sso_service.pynew file mode 100644index 00000000..2da6da29--- /dev/null+++ b/backend/app/services/db_admin_sso_service.py@@ -0,0 +1,211 @@+"""One-click DB admin SSO via a disposable Adminer container.++``launch()`` mints a short-lived, single-database shadow credential+(``ManagedDatabaseUser`` with ``is_shadow=True``), makes sure a containerized+Adminer is running (labelled ``serverkit.role=adminer-sso``, random high host+port, on the ``serverkit`` network), and returns a launch descriptor the+frontend POSTs straight into Adminer's login form. The password crosses exactly+once in that response and is never persisted.++``reap()`` (job kind ``databases.sso.reap``) drops expired shadow users+engine-side + their rows, and stops the Adminer container after 15 idle+minutes. All docker interaction funnels through the single choke-point+``_docker`` so tests can stub it. Linux/docker-only by design.+"""+import logging+import os+import secrets+import subprocess+from datetime import datetime, timedelta++logger = logging.getLogger(__name__)++SHADOW_TTL_MINUTES = 5+ADMINER_IDLE_MINUTES = 15++ADMINER_IMAGE = 'adminer:latest'+ADMINER_CONTAINER = 'serverkit-adminer-sso'+ADMINER_LABEL = 'serverkit.role=adminer-sso'+NETWORK_NAME = 'serverkit' # same network the proxy stacks use++REAP_JOB_KIND = 'databases.sso.reap'+REAP_SCHEDULE_NAME = 'db-sso-reap'++# Adminer login-form driver values per engine.+_ADMINER_DRIVERS = {'mysql': 'server', 'postgresql': 'pgsql'}+++class DbAdminSsoService:+ """Mint scoped shadow credentials and hand out Adminer launch descriptors."""++ # Last time an SSO launch used the Adminer container (per-process; the+ # panel is single-worker by design so this is authoritative enough).+ _last_used_at = None++ # ── choke-point: ALL docker interaction goes through here (tests stub it) ──+ @classmethod+ def _docker(cls, args, timeout=60):+ """Run ``docker <args>``; returns {'success', 'output', 'error'}."""+ try:+ result = subprocess.run(['docker'] + list(args),+ capture_output=True, text=True, timeout=timeout)+ return {+ 'success': result.returncode == 0,+ 'output': result.stdout,+ 'error': result.stderr if result.returncode != 0 else None,+ }+ except FileNotFoundError:+ return {'success': False, 'error': 'Docker not found'}+ except subprocess.TimeoutExpired:+ return {'success': False, 'error': 'Docker command timed out'}+ except Exception as e:+ return {'success': False, 'error': str(e)}++ @classmethod+ def _docker_available(cls):+ if os.name == 'nt':+ return False+ return cls._docker(['version', '--format', '{{.Server.Version}}'],+ timeout=10).get('success', False)++ # ── Adminer container lifecycle ──+ @classmethod+ def _find_adminer_port(cls):+ """Host port of an already-running labelled Adminer, or None."""+ result = cls._docker(['ps', '--filter', f'label={ADMINER_LABEL}',+ '--filter', 'status=running',+ '--format', '{{.Names}}'])+ if not result.get('success') or not (result.get('output') or '').strip():+ return None+ name = result['output'].strip().split('\n')[0].strip()+ port_result = cls._docker(['port', name, '8080/tcp'])+ if not port_result.get('success'):+ return None+ # e.g. "0.0.0.0:31245" (possibly one line per address family)+ for line in (port_result.get('output') or '').strip().split('\n'):+ if ':' in line:+ try:+ return int(line.rsplit(':', 1)[1])+ except ValueError:+ continue+ return None++ @classmethod+ def _ensure_adminer(cls):+ """Reuse the running labelled Adminer or start a fresh one.+ Returns ``{'port': int}`` or ``{'error': msg}``."""+ port = cls._find_adminer_port()+ if port:+ return {'port': port}++ # A stopped leftover with our name blocks docker run — clear it first.+ cls._docker(['rm', '-f', ADMINER_CONTAINER])+ # The shared network usually exists (proxy stacks); create is idempotent+ # enough for our purposes — failure just means it's already there.+ cls._docker(['network', 'create', NETWORK_NAME])++ host_port = 20000 + secrets.randbelow(20000) # random high port+ result = cls._docker([+ 'run', '-d',+ '--name', ADMINER_CONTAINER,+ '--label', ADMINER_LABEL,+ '--network', NETWORK_NAME,+ '--add-host', 'host.docker.internal:host-gateway',+ '-p', f'{host_port}:8080',+ '--restart', 'no',+ ADMINER_IMAGE,+ ])+ if not result.get('success'):+ return {'error': result.get('error') or 'Failed to start Adminer'}+ return {'port': host_port}++ @classmethod+ def _server_for(cls, managed):+ """The DB host as reachable FROM the Adminer container."""+ if managed.host_kind == 'docker' and managed.container_ref:+ # Same docker network — the container name resolves directly.+ return managed.container_ref+ host = managed.host or 'localhost'+ if host in ('localhost', '127.0.0.1'):+ host = 'host.docker.internal'+ port = managed.effective_port()+ return f'{host}:{port}' if port else host++ # ── the headline ──+ @classmethod+ def launch(cls, managed, requested_by=None):+ """Mint a scoped shadow credential + return the Adminer launch descriptor.++ The returned password exists only in this response — it is never stored+ or logged. Grants are ALL on this ONE database, nothing else.+ """+ from app.services.managed_db_user_service import ManagedDbUserService++ driver = _ADMINER_DRIVERS.get(managed.engine)+ if not driver:+ return {'error': 'unsupported engine'}+ if not cls._docker_available():+ return {'error': 'Docker required'}++ expires_at = datetime.utcnow() + timedelta(minutes=SHADOW_TTL_MINUTES)+ username = f'sk_sso_{secrets.token_hex(3)}'+ created = ManagedDbUserService.create_user(+ managed, username=username, grants=['ALL'],+ is_shadow=True, expires_at=expires_at,+ )+ if 'error' in created:+ return created++ adminer = cls._ensure_adminer()+ if 'error' in adminer:+ # Don't leave a live credential behind a failed launch.+ from app.models.managed_database_user import ManagedDatabaseUser+ from app import db+ row = ManagedDatabaseUser.query.get(created['user']['id'])+ if row is not None:+ for sql in ManagedDbUserService._drop_user_sql(managed.engine, username):+ ManagedDbUserService._exec_sql(managed, sql)+ db.session.delete(row)+ db.session.commit()+ return adminer++ cls._last_used_at = datetime.utcnow()+ logger.info('SSO launch for managed db %s (%s) by user %s as %s',+ managed.id, managed.name, requested_by, username)+ return {+ 'port': adminer['port'],+ 'driver': driver,+ 'server': cls._server_for(managed),+ 'username': username,+ 'password': created['password'], # crosses once, never persisted+ 'database': managed.name,+ 'expires_at': expires_at.isoformat(),+ }++ # ── reaping ──+ @classmethod+ def reap(cls):+ """Drop expired shadow credentials and stop an idle Adminer.+ Returns ``{'users_removed': int, 'adminer_stopped': bool}``."""+ from app.services.managed_db_user_service import ManagedDbUserService++ removed = ManagedDbUserService.reap_expired_shadow_users()++ stopped = False+ idle_cutoff = datetime.utcnow() - timedelta(minutes=ADMINER_IDLE_MINUTES)+ if (cls._last_used_at is None or cls._last_used_at < idle_cutoff) \+ and os.name != 'nt':+ if cls._find_adminer_port() is not None:+ result = cls._docker(['rm', '-f', ADMINER_CONTAINER])+ stopped = bool(result.get('success'))+ if stopped:+ logger.info('Stopped idle Adminer SSO container')+ return {'users_removed': removed, 'adminer_stopped': stopped}++ @classmethod+ def register_jobs(cls):+ """Register the reap handler with the unified job system. The schedule+ row is seeded with the other builtins in seed_builtin_schedules().+ Called once at app startup (see app/__init__.py)."""+ from app.jobs import registry+ registry.register(REAP_JOB_KIND, lambda job: cls.reap(), replace=True)diff --git a/backend/app/services/managed_db_user_service.py b/backend/app/services/managed_db_user_service.pynew file mode 100644index 00000000..6d4f6768--- /dev/null+++ b/backend/app/services/managed_db_user_service.py@@ -0,0 +1,282 @@+"""Managed database users — durable rows for the users/grants ServerKit creates.++The engines already know their users; ServerKit didn't. This service creates+users *in* the engine (CREATE USER / GRANT via the same host/docker exec paths+``database_service`` uses) and records a ``ManagedDatabaseUser`` row beside the+managed database so the panel survives restarts and SSO can mint scoped,+single-use shadow credentials.++Passwords are generated with ``secrets`` unless supplied, returned exactly once+from ``create_user`` and never stored or logged. All engine SQL funnels through+the single choke-point ``_exec_sql`` so tests can stub it.+"""+import logging+import re+import secrets+import subprocess+from datetime import datetime++from app import db+from app.models.managed_database_user import ManagedDatabaseUser # explicit import registers the table+from app.services.database_service import DatabaseService+from app.utils.crypto import decrypt_secret_safe++logger = logging.getLogger(__name__)++SUPPORTED_ENGINES = ('mysql', 'postgresql')++# Engine identifiers we will interpolate into SQL. Deliberately strict.+_USERNAME_RE = re.compile(r'^[A-Za-z0-9_]{1,32}$')+_DBNAME_RE = re.compile(r'^[A-Za-z0-9_\-]{1,64}$')+# Grant keywords: uppercase words (optionally multi-word, e.g. LOCK TABLES).+_GRANT_RE = re.compile(r'^[A-Z][A-Z_ ]{0,40}$')+++class ManagedDbUserService:+ """Create/list/delete database users on a managed database + track rows."""++ # ── choke-point: all engine SQL goes through here (tests monkeypatch it) ──+ @classmethod+ def _exec_sql(cls, managed, sql):+ """Execute ``sql`` against the engine backing ``managed``.++ Returns the ``{'success': bool, 'output': str, 'error': str|None}``+ shape of ``DatabaseService`` executors.+ """+ secret = decrypt_secret_safe(managed.admin_secret_encrypted or '') or None+ if managed.engine == 'mysql':+ if managed.host_kind == 'docker' and managed.container_ref:+ return DatabaseService.docker_mysql_execute(+ managed.container_ref, sql,+ user=managed.admin_username or 'root', password=secret)+ return DatabaseService.mysql_execute(sql, root_password=secret)+ if managed.engine == 'postgresql':+ if managed.host_kind == 'docker' and managed.container_ref:+ return cls._docker_pg_execute(+ managed.container_ref, sql,+ user=managed.admin_username or 'postgres', password=secret)+ return DatabaseService.pg_execute(sql)+ return {'success': False, 'error': 'unsupported engine'}++ @staticmethod+ def _docker_pg_execute(container_name, sql, user='postgres', password=None):+ """psql inside a Docker container (database_service has no pg twin of+ docker_mysql_execute, so this fills that gap here)."""+ try:+ cmd = ['docker', 'exec']+ if password:+ cmd.extend(['-e', f'PGPASSWORD={password}'])+ cmd.extend([container_name, 'psql', '-U', user, '-d', 'postgres',+ '-c', sql, '-t', '-A'])+ result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)+ return {+ 'success': result.returncode == 0,+ 'output': result.stdout,+ 'error': result.stderr if result.returncode != 0 else None,+ }+ except subprocess.TimeoutExpired:+ return {'success': False, 'error': 'Query timed out'}+ except Exception as e:+ return {'success': False, 'error': str(e)}++ # ── validation / quoting helpers ──+ @staticmethod+ def generate_password():+ return secrets.token_urlsafe(24)++ @staticmethod+ def _validate_username(username):+ return bool(username) and bool(_USERNAME_RE.match(username))++ @staticmethod+ def _validate_grants(grants):+ return all(isinstance(g, str) and _GRANT_RE.match(g.strip().upper())+ for g in grants)++ @staticmethod+ def _escape_mysql_string(value):+ return value.replace('\\', '\\\\').replace("'", "\\'")++ @staticmethod+ def _escape_pg_string(value):+ return value.replace("'", "''")++ # ── SQL builders (pure, unit-testable) ──+ @classmethod+ def _create_user_sql(cls, engine, db_name, username, password, grants):+ """The statements that create + scope a user to ONE database."""+ grant_list = ', '.join(g.strip().upper() for g in grants)+ if engine == 'mysql':+ pw = cls._escape_mysql_string(password)+ privs = 'ALL PRIVILEGES' if grant_list == 'ALL' else grant_list+ return [+ f"CREATE USER '{username}'@'%' IDENTIFIED BY '{pw}';",+ f"GRANT {privs} ON `{db_name}`.* TO '{username}'@'%';",+ 'FLUSH PRIVILEGES;',+ ]+ if engine == 'postgresql':+ pw = cls._escape_pg_string(password)+ stmts = [f"CREATE USER \"{username}\" WITH PASSWORD '{pw}';"]+ if grant_list == 'ALL':+ stmts.append(+ f'GRANT ALL PRIVILEGES ON DATABASE "{db_name}" TO "{username}";')+ else:+ stmts.append(+ f'GRANT CONNECT ON DATABASE "{db_name}" TO "{username}";')+ stmts.append(+ f'GRANT {grant_list} ON ALL TABLES IN SCHEMA public TO "{username}";')+ return stmts+ return []++ @classmethod+ def _drop_user_sql(cls, engine, username):+ if engine == 'mysql':+ return [f"DROP USER IF EXISTS '{username}'@'%';", 'FLUSH PRIVILEGES;']+ if engine == 'postgresql':+ return [f'DROP USER IF EXISTS "{username}";']+ return []++ # ── operations ──+ @classmethod+ def create_user(cls, managed, username=None, password=None, grants=None,+ is_shadow=False, expires_at=None):+ """CREATE USER + GRANT scoped to this one database, then record the row.++ Returns ``{'user': dict, 'password': str}`` — the only time the+ password is ever visible — or ``{'error': msg}``.+ """+ if managed.engine not in SUPPORTED_ENGINES:+ return {'error': 'unsupported engine'}+ if not _DBNAME_RE.match(managed.name or ''):+ return {'error': 'Invalid database name'}++ username = (username or f'sk_{secrets.token_hex(3)}').strip()+ if not cls._validate_username(username):+ return {'error': 'Invalid username: letters, digits and underscores only (max 32)'}++ grants = list(grants or ['ALL'])+ if not grants or not cls._validate_grants(grants):+ return {'error': 'Invalid grants'}++ existing = ManagedDatabaseUser.query.filter_by(+ managed_database_id=managed.id, username=username).first()+ if existing:+ return {'error': 'User already tracked for this database'}++ password = password or cls.generate_password()++ for sql in cls._create_user_sql(managed.engine, managed.name,+ username, password, grants):+ result = cls._exec_sql(managed, sql)+ if not result.get('success'):+ # Best-effort cleanup so a failed GRANT doesn't leave an orphan user.+ for cleanup in cls._drop_user_sql(managed.engine, username):+ cls._exec_sql(managed, cleanup)+ return {'error': result.get('error') or 'Engine statement failed'}++ row = cls.ensure_recorded(managed, username, grants=grants,+ is_shadow=is_shadow, expires_at=expires_at)+ return {'user': row.to_dict(), 'password': password}++ @classmethod+ def ensure_recorded(cls, managed, username, grants=None, is_shadow=False,+ expires_at=None):+ """Find-or-create the tracking row WITHOUT touching the engine —+ used to adopt users that already exist server-side."""+ row = ManagedDatabaseUser.query.filter_by(+ managed_database_id=managed.id, username=username).first()+ if row is None:+ row = ManagedDatabaseUser(managed_database_id=managed.id,+ username=username)+ db.session.add(row)+ row.set_grants(grants or ['ALL'])+ row.is_shadow = bool(is_shadow)+ row.expires_at = expires_at+ db.session.commit()+ return row++ @classmethod+ def list_users(cls, managed, include_shadow=False):+ """Tracked rows merged best-effort with the live engine user list.++ Each tracked row carries ``present`` (True/False/None=unknown); live+ users ServerKit didn't create are appended as untracked stubs.+ """+ q = ManagedDatabaseUser.query.filter_by(managed_database_id=managed.id)+ if not include_shadow:+ q = q.filter_by(is_shadow=False)+ rows = q.order_by(ManagedDatabaseUser.created_at.asc()).all()++ live = cls._list_engine_usernames(managed)+ users = []+ for row in rows:+ present = None if live is None else (row.username in live)+ users.append(row.to_dict(live={'present': present}))+ if live is not None:+ tracked = {r.username for r in rows}+ for name in live:+ if name not in tracked and not name.startswith('sk_sso_'):+ users.append({'username': name, 'tracked': False, 'present': True})+ return users++ @classmethod+ def _list_engine_usernames(cls, managed):+ """Best-effort live usernames, or None when the engine is unreachable."""+ if managed.engine == 'mysql':+ sql = "SELECT User FROM mysql.user WHERE User NOT IN ('root', 'mysql.sys', 'mysql.session', 'mysql.infoschema');"+ elif managed.engine == 'postgresql':+ sql = "SELECT rolname FROM pg_roles WHERE rolcanlogin = true AND rolname <> 'postgres';"+ else:+ return None+ try:+ result = cls._exec_sql(managed, sql)+ if not result.get('success'):+ return None+ lines = [ln.strip() for ln in (result.get('output') or '').strip().split('\n')]+ # mysql CLI prints a header row; psql -t -A does not.+ if managed.engine == 'mysql' and lines and lines[0].lower() == 'user':+ lines = lines[1:]+ return [ln for ln in lines if ln]+ except Exception as e: # pragma: no cover - defensive+ logger.debug('live user listing failed for %s: %s', managed.name, e)+ return None++ @classmethod+ def delete_user(cls, managed, row):+ """DROP USER in the engine, then remove the tracking row."""+ if managed.engine not in SUPPORTED_ENGINES:+ return {'error': 'unsupported engine'}+ for sql in cls._drop_user_sql(managed.engine, row.username):+ result = cls._exec_sql(managed, sql)+ if not result.get('success'):+ return {'error': result.get('error') or 'DROP USER failed'}+ db.session.delete(row)+ db.session.commit()+ return {'success': True}++ @classmethod+ def reap_expired_shadow_users(cls):+ """Drop expired shadow credentials engine-side and delete their rows.+ Best-effort per user; returns the number of rows removed."""+ now = datetime.utcnow()+ expired = (ManagedDatabaseUser.query+ .filter(ManagedDatabaseUser.is_shadow.is_(True))+ .filter(ManagedDatabaseUser.expires_at.isnot(None))+ .filter(ManagedDatabaseUser.expires_at < now)+ .all())+ removed = 0+ for row in expired:+ managed = row.managed_database+ try:+ if managed is not None:+ for sql in cls._drop_user_sql(managed.engine, row.username):+ cls._exec_sql(managed, sql)+ except Exception as e: # pragma: no cover - defensive+ logger.warning('Failed to drop expired shadow user %s: %s',+ row.username, e)+ db.session.delete(row)+ removed += 1+ if removed:+ db.session.commit()+ logger.info('Reaped %d expired shadow database user(s)', removed)+ return removeddiff --git a/backend/migrations/versions/050_managed_database_users.py b/backend/migrations/versions/050_managed_database_users.pynew file mode 100644index 00000000..07fb55bd--- /dev/null+++ b/backend/migrations/versions/050_managed_database_users.py@@ -0,0 +1,54 @@+"""Managed database users.++Adds the managed_database_users table: durable rows for users/grants ServerKit+creates on managed databases, including short-lived shadow credentials for+one-click admin SSO. Passwords are never stored.++Idempotent: MigrationService runs _fix_missing_columns() + db.create_all() on boot+before Alembic, so guard on the live schema.++Revision ID: 050_managed_database_users+Revises: 049_login_links+Create Date: 2026-07-03+"""+from alembic import op+import sqlalchemy as sa++revision = '050_managed_database_users'+down_revision = '049_login_links'+branch_labels = None+depends_on = None++TABLE = 'managed_database_users'+++def upgrade():+ conn = op.get_bind()+ inspector = sa.inspect(conn)+ if TABLE in set(inspector.get_table_names()):+ return+ op.create_table(+ TABLE,+ sa.Column('id', sa.Integer(), primary_key=True),+ sa.Column('managed_database_id', sa.Integer(),+ sa.ForeignKey('managed_databases.id', ondelete='CASCADE'),+ nullable=False),+ sa.Column('username', sa.String(120), nullable=False),+ sa.Column('grants', sa.Text(), nullable=False, server_default='["ALL"]'),+ sa.Column('is_shadow', sa.Boolean(), nullable=False, server_default=sa.false()),+ sa.Column('expires_at', sa.DateTime(), nullable=True),+ sa.Column('created_at', sa.DateTime(), nullable=True),+ sa.Column('updated_at', sa.DateTime(), nullable=True),+ sa.UniqueConstraint('managed_database_id', 'username',+ name='uq_managed_db_user'),+ )+ op.create_index('ix_managed_database_users_managed_database_id',+ TABLE, ['managed_database_id'])+++def downgrade():+ conn = op.get_bind()+ inspector = sa.inspect(conn)+ if TABLE not in set(inspector.get_table_names()):+ return+ op.drop_table(TABLE)diff --git a/backend/tests/test_db_admin_sso.py b/backend/tests/test_db_admin_sso.pynew file mode 100644index 00000000..a922d37e--- /dev/null+++ b/backend/tests/test_db_admin_sso.py@@ -0,0 +1,232 @@+"""One-click DB admin SSO via Adminer — launch descriptor shape with docker+stubbed, shadow-credential scoping, reaping, and the API surface.++Docker and engine SQL are stubbed at their single choke-points+(``DbAdminSsoService._docker`` / ``ManagedDbUserService._exec_sql``).+"""+from datetime import datetime, timedelta++import pytest++from app import db+from app.models.managed_database_user import ManagedDatabaseUser+from app.services.managed_database_service import ManagedDatabaseService+from app.services.managed_db_user_service import ManagedDbUserService+from app.services.db_admin_sso_service import (+ DbAdminSsoService, ADMINER_LABEL, ADMINER_CONTAINER, REAP_JOB_KIND,+)+++def managed(app):+ return ManagedDatabaseService.record_provisioned(+ 'mysql', 'shop', host='localhost', port=3306,+ admin_username='root', admin_secret='rootpw',+ )+++def docker_managed(app):+ return ManagedDatabaseService.record_provisioned(+ 'postgresql', 'reports', host_kind='docker', container_ref='pg-main',+ )+++def sql_log(monkeypatch):+ executed = []+ monkeypatch.setattr(ManagedDbUserService, '_exec_sql', classmethod(+ lambda cls, m, sql: (executed.append(sql) or+ {'success': True, 'output': '', 'error': None})))+ return executed+++def docker_stub(monkeypatch):+ """Stub the docker choke-point: no running Adminer, run succeeds."""+ calls = []++ def fake_docker(cls, args, timeout=60):+ calls.append(list(args))+ if args[0] == 'ps':+ return {'success': True, 'output': '', 'error': None} # none running+ if args[0] == 'run':+ return {'success': True, 'output': 'abc123', 'error': None}+ return {'success': True, 'output': '', 'error': None}++ monkeypatch.setattr(DbAdminSsoService, '_docker', classmethod(fake_docker))+ monkeypatch.setattr(DbAdminSsoService, '_docker_available',+ classmethod(lambda cls: True))+ DbAdminSsoService._last_used_at = None+ return calls+++# ── launch descriptor ────────────────────────────────────────────────────────++def test_launch_descriptor_shape(app, managed, sql_log, docker_stub):+ d = DbAdminSsoService.launch(managed, requested_by=1)+ assert set(d) >= {'port', 'driver', 'server', 'username', 'password',+ 'database', 'expires_at'}+ assert d['driver'] == 'server' # Adminer's MySQL driver+ assert d['database'] == 'shop'+ assert d['username'].startswith('sk_sso_')+ assert 20000 <= d['port'] < 40000+ # host engine as seen FROM the adminer container+ assert d['server'] == 'host.docker.internal:3306'+ # a run happened with our label + network + published port+ run = next(c for c in docker_stub if c[0] == 'run')+ assert '--label' in run and ADMINER_LABEL in run+ assert '--network' in run and 'serverkit' in run+++def test_launch_mints_scoped_shadow_credential(app, managed, sql_log, docker_stub):+ d = DbAdminSsoService.launch(managed)+ row = ManagedDatabaseUser.query.filter_by(username=d['username']).one()+ assert row.is_shadow is True+ assert row.expires_at is not None+ assert row.expires_at <= datetime.utcnow() + timedelta(minutes=5, seconds=5)+ # grants scoped to THAT one database only+ grant_sql = next(s for s in sql_log if s.startswith('GRANT'))+ assert 'ON `shop`.*' in grant_sql+ assert '*.*' not in grant_sql+ # password crosses once in the descriptor, never persisted+ assert d['password'] not in (row.grants or '')+ assert not hasattr(row, 'password')+++def test_launch_docker_engine_server_is_container_name(app, docker_managed,+ sql_log, docker_stub):+ d = DbAdminSsoService.launch(docker_managed)+ assert d['server'] == 'pg-main' # same docker network+ assert d['driver'] == 'pgsql'+++def test_launch_reuses_running_adminer(app, managed, sql_log, monkeypatch):+ def fake_docker(cls, args, timeout=60):+ if args[0] == 'ps':+ return {'success': True, 'output': 'serverkit-adminer-sso\n', 'error': None}+ if args[0] == 'port':+ return {'success': True, 'output': '0.0.0.0:31245\n', 'error': None}+ raise AssertionError(f'unexpected docker call: {args}')++ monkeypatch.setattr(DbAdminSsoService, '_docker', classmethod(fake_docker))+ monkeypatch.setattr(DbAdminSsoService, '_docker_available',+ classmethod(lambda cls: True))+ d = DbAdminSsoService.launch(managed)+ assert d['port'] == 31245 # no new container run+++def test_launch_without_docker_is_clean_error(app, managed, monkeypatch):+ monkeypatch.setattr(DbAdminSsoService, '_docker_available',+ classmethod(lambda cls: False))+ assert DbAdminSsoService.launch(managed) == {'error': 'Docker required'}+ assert ManagedDatabaseUser.query.count() == 0 # nothing minted+++def test_launch_unsupported_engine(app, docker_stub):+ mongo = ManagedDatabaseService.record_provisioned('mongodb', 'logs')+ assert DbAdminSsoService.launch(mongo) == {'error': 'unsupported engine'}+++def test_launch_adminer_failure_revokes_credential(app, managed, sql_log, monkeypatch):+ def fake_docker(cls, args, timeout=60):+ if args[0] == 'ps':+ return {'success': True, 'output': '', 'error': None}+ return {'success': False, 'output': '', 'error': 'no docker for you'}++ monkeypatch.setattr(DbAdminSsoService, '_docker', classmethod(fake_docker))+ monkeypatch.setattr(DbAdminSsoService, '_docker_available',+ classmethod(lambda cls: True))+ result = DbAdminSsoService.launch(managed)+ assert result == {'error': 'no docker for you'}+ assert ManagedDatabaseUser.query.count() == 0 # row revoked+ assert any(s.startswith('DROP USER') for s in sql_log) # engine-side too+++# ── reap ─────────────────────────────────────────────────────────────────────++def test_reap_removes_expired_and_stops_idle_adminer(app, managed, sql_log, monkeypatch):+ ManagedDbUserService.ensure_recorded(+ managed, 'sk_sso_dead', is_shadow=True,+ expires_at=datetime.utcnow() - timedelta(minutes=1))++ calls = []++ def fake_docker(cls, args, timeout=60):+ calls.append(list(args))+ if args[0] == 'ps':+ return {'success': True, 'output': 'serverkit-adminer-sso\n', 'error': None}+ if args[0] == 'port':+ return {'success': True, 'output': '0.0.0.0:31245\n', 'error': None}+ return {'success': True, 'output': '', 'error': None}++ monkeypatch.setattr(DbAdminSsoService, '_docker', classmethod(fake_docker))+ monkeypatch.setattr('app.services.db_admin_sso_service.os.name', 'posix')+ DbAdminSsoService._last_used_at = datetime.utcnow() - timedelta(minutes=20)++ result = DbAdminSsoService.reap()+ assert result['users_removed'] == 1+ assert result['adminer_stopped'] is True+ assert ['rm', '-f', ADMINER_CONTAINER] in calls+ assert ManagedDatabaseUser.query.count() == 0+++def test_reap_keeps_recently_used_adminer(app, monkeypatch):+ calls = []+ monkeypatch.setattr(DbAdminSsoService, '_docker', classmethod(+ lambda cls, args, timeout=60: (calls.append(list(args)) or+ {'success': True, 'output': '', 'error': None})))+ DbAdminSsoService._last_used_at = datetime.utcnow()+ result = DbAdminSsoService.reap()+ assert result['adminer_stopped'] is False+ assert ['rm', '-f', ADMINER_CONTAINER] not in calls+++def test_register_jobs_registers_reap_kind(app):+ from app.jobs import registry+ DbAdminSsoService.register_jobs()+ assert REAP_JOB_KIND in registry.registered_kinds()+++# ── API ──────────────────────────────────────────────────────────────────────++def _register_bp(app):+ from app.api.managed_db_users import managed_db_users_bp+ if 'managed_db_users' not in app.blueprints:+ app.register_blueprint(managed_db_users_bp, url_prefix='/api/v1/managed-databases')+++def test_api_sso_launch(app, client, auth_headers, managed, sql_log, docker_stub):+ _register_bp(app)+ resp = client.post(f'/api/v1/managed-databases/{managed.id}/sso',+ headers=auth_headers)+ assert resp.status_code == 200+ d = resp.get_json()+ assert d['url'].startswith('http://') and str(d['port']) in d['url']+ assert d['database'] == 'shop' and d['password']+++def test_api_sso_requires_admin(app, client, managed):+ _register_bp(app)+ from flask_jwt_extended import create_access_token+ from werkzeug.security import generate_password_hash+ from app.models import User++ dev = User(email='[email protected]', username='ssodev',+ password_hash=generate_password_hash('x'),+ role=User.ROLE_DEVELOPER, is_active=True)+ db.session.add(dev)+ db.session.commit()+ headers = {'Authorization': f'Bearer {create_access_token(identity=dev.id)}'}+ resp = client.post(f'/api/v1/managed-databases/{managed.id}/sso', headers=headers)+ assert resp.status_code == 403+++def test_api_sso_docker_required_is_503(app, client, auth_headers, managed, monkeypatch):+ _register_bp(app)+ monkeypatch.setattr(DbAdminSsoService, '_docker_available',+ classmethod(lambda cls: False))+ resp = client.post(f'/api/v1/managed-databases/{managed.id}/sso',+ headers=auth_headers)+ assert resp.status_code == 503+ assert resp.get_json() == {'error': 'Docker required'}diff --git a/backend/tests/test_managed_db_users.py b/backend/tests/test_managed_db_users.pynew file mode 100644index 00000000..d4b95910--- /dev/null+++ b/backend/tests/test_managed_db_users.py@@ -0,0 +1,274 @@+"""Managed database users — model round-trip, SQL generation through the+stubbed ``_exec_sql`` choke-point, scoped grants, expiry reaping, and API.++The blueprint is not yet wired into ``app/__init__.py`` (WIRING pending), so+API tests register it on the test app manually.+"""+from datetime import datetime, timedelta++import pytest++from app import db+from app.models.managed_database_user import ManagedDatabaseUser+from app.services.managed_database_service import ManagedDatabaseService+from app.services.managed_db_user_service import ManagedDbUserService+++def managed(app):+ return ManagedDatabaseService.record_provisioned(+ 'mysql', 'shop', host='localhost', port=3306,+ admin_username='root', admin_secret='rootpw',+ )+++def pg_managed(app):+ return ManagedDatabaseService.record_provisioned(+ 'postgresql', 'reports', admin_username='postgres', admin_secret='pgpw',+ )+++def sql_log(monkeypatch):+ """Stub the single SQL choke-point; capture every statement."""+ executed = []++ def fake_exec(managed, sql):+ executed.append(sql)+ return {'success': True, 'output': '', 'error': None}++ monkeypatch.setattr(ManagedDbUserService, '_exec_sql', classmethod(+ lambda cls, managed, sql: fake_exec(managed, sql)))+ return executed+++def _register_bp(app):+ from app.api.managed_db_users import managed_db_users_bp+ if 'managed_db_users' not in app.blueprints:+ app.register_blueprint(managed_db_users_bp, url_prefix='/api/v1/managed-databases')+ return app+++# ── model round-trip ─────────────────────────────────────────────────────────++def test_model_round_trip(app, managed):+ row = ManagedDatabaseUser(managed_database_id=managed.id, username='app_rw')+ row.set_grants(['SELECT', 'INSERT'])+ db.session.add(row)+ db.session.commit()++ fetched = ManagedDatabaseUser.query.filter_by(username='app_rw').one()+ assert fetched.get_grants() == ['SELECT', 'INSERT']+ assert fetched.is_shadow is False+ assert fetched.is_expired is False+ d = fetched.to_dict()+ assert d['username'] == 'app_rw' and d['managed_database_id'] == managed.id+ assert d['grants'] == ['SELECT', 'INSERT']+ assert 'password' not in d # never modeled, never serialized+++def test_username_unique_per_database(app, managed):+ db.session.add(ManagedDatabaseUser(managed_database_id=managed.id, username='dup'))+ db.session.commit()+ db.session.add(ManagedDatabaseUser(managed_database_id=managed.id, username='dup'))+ with pytest.raises(Exception):+ db.session.commit()+ db.session.rollback()+++def test_rows_cascade_with_managed_database(app, managed):+ ManagedDbUserService.ensure_recorded(managed, 'orphan_check')+ assert ManagedDatabaseUser.query.count() == 1+ ManagedDatabaseService.delete(managed, drop=False)+ assert ManagedDatabaseUser.query.count() == 0+++# ── create_user SQL generation ───────────────────────────────────────────────++def test_create_user_mysql_sql(app, managed, sql_log):+ result = ManagedDbUserService.create_user(+ managed, username='app_rw', password="p'w\\d", grants=['SELECT', 'INSERT'])+ assert 'error' not in result+ assert result['password'] == "p'w\\d" # returned once+ # proper escaping: backslash then quote escaped for MySQL+ assert sql_log[0] == "CREATE USER 'app_rw'@'%' IDENTIFIED BY 'p\\'w\\\\d';"+ assert sql_log[1] == "GRANT SELECT, INSERT ON `shop`.* TO 'app_rw'@'%';"+ assert sql_log[2] == 'FLUSH PRIVILEGES;'+ row = ManagedDatabaseUser.query.filter_by(username='app_rw').one()+ assert row.get_grants() == ['SELECT', 'INSERT']+ # the password is nowhere in the row+ assert "p'w" not in (row.grants or '')+++def test_create_user_mysql_all_privileges(app, managed, sql_log):+ ManagedDbUserService.create_user(managed, username='full', password='x')+ assert sql_log[1] == "GRANT ALL PRIVILEGES ON `shop`.* TO 'full'@'%';"+++def test_create_user_postgresql_sql(app, pg_managed, sql_log):+ result = ManagedDbUserService.create_user(+ pg_managed, username='rpt_ro', password="o'brien", grants=['SELECT'])+ assert 'error' not in result+ assert sql_log[0] == "CREATE USER \"rpt_ro\" WITH PASSWORD 'o''brien';" # '' escaping+ assert sql_log[1] == 'GRANT CONNECT ON DATABASE "reports" TO "rpt_ro";'+ assert sql_log[2] == 'GRANT SELECT ON ALL TABLES IN SCHEMA public TO "rpt_ro";'+++def test_create_user_generates_strong_password(app, managed, sql_log):+ result = ManagedDbUserService.create_user(managed, username='gen1')+ assert len(result['password']) >= 24+++def test_create_user_rejects_bad_username(app, managed, sql_log):+ result = ManagedDbUserService.create_user(managed, username="bad'; DROP TABLE x;--")+ assert result == {'error': 'Invalid username: letters, digits and underscores only (max 32)'}+ assert sql_log == [] # nothing reached the engine+++def test_create_user_rejects_bad_grants(app, managed, sql_log):+ result = ManagedDbUserService.create_user(managed, username='ok', grants=["SELECT'; DROP"])+ assert result == {'error': 'Invalid grants'}+ assert sql_log == []+++def test_create_user_unsupported_engine(app, sql_log):+ mongo = ManagedDatabaseService.record_provisioned('mongodb', 'logs')+ assert ManagedDbUserService.create_user(mongo, username='u1') == {'error': 'unsupported engine'}+ assert sql_log == []+++def test_create_user_engine_failure_cleans_up(app, managed, monkeypatch):+ calls = []++ def fake(cls, managed_, sql):+ calls.append(sql)+ if sql.startswith('GRANT'):+ return {'success': False, 'error': 'boom'}+ return {'success': True, 'output': '', 'error': None}++ monkeypatch.setattr(ManagedDbUserService, '_exec_sql', classmethod(fake))+ result = ManagedDbUserService.create_user(managed, username='half')+ assert result == {'error': 'boom'}+ assert ManagedDatabaseUser.query.count() == 0 # no orphan row+ assert any(s.startswith('DROP USER') for s in calls) # engine cleanup attempted+++# ── list / delete / ensure_recorded ──────────────────────────────────────────++def test_list_users_merges_live_engine_users(app, managed, monkeypatch):+ ManagedDbUserService.ensure_recorded(managed, 'tracked_one')+ monkeypatch.setattr(ManagedDbUserService, '_list_engine_usernames',+ classmethod(lambda cls, m: ['tracked_one', 'wild_user']))+ users = ManagedDbUserService.list_users(managed)+ by_name = {u['username']: u for u in users}+ assert by_name['tracked_one']['present'] is True+ assert by_name['wild_user'] == {'username': 'wild_user', 'tracked': False, 'present': True}+++def test_list_users_engine_unreachable(app, managed, monkeypatch):+ ManagedDbUserService.ensure_recorded(managed, 'tracked_one')+ monkeypatch.setattr(ManagedDbUserService, '_list_engine_usernames',+ classmethod(lambda cls, m: None))+ users = ManagedDbUserService.list_users(managed)+ assert users[0]['present'] is None # unknown, not False+++def test_list_users_hides_shadow_by_default(app, managed):+ ManagedDbUserService.ensure_recorded(managed, 'sk_sso_abc123', is_shadow=True)+ assert ManagedDbUserService.list_users(managed) == [] or all(+ not u.get('is_shadow') for u in ManagedDbUserService.list_users(managed))+++def test_delete_user_drops_and_removes_row(app, managed, sql_log):+ row = ManagedDbUserService.ensure_recorded(managed, 'goner')+ result = ManagedDbUserService.delete_user(managed, row)+ assert result == {'success': True}+ assert sql_log[0] == "DROP USER IF EXISTS 'goner'@'%';"+ assert ManagedDatabaseUser.query.count() == 0+++def test_ensure_recorded_is_idempotent(app, managed):+ a = ManagedDbUserService.ensure_recorded(managed, 'same')+ b = ManagedDbUserService.ensure_recorded(managed, 'same', grants=['SELECT'])+ assert a.id == b.id+ assert b.get_grants() == ['SELECT']+ assert ManagedDatabaseUser.query.count() == 1+++# ── expiry reap ──────────────────────────────────────────────────────────────++def test_reap_drops_only_expired_shadow_users(app, managed, sql_log):+ ManagedDbUserService.ensure_recorded(+ managed, 'sk_sso_dead', is_shadow=True,+ expires_at=datetime.utcnow() - timedelta(minutes=1))+ ManagedDbUserService.ensure_recorded(+ managed, 'sk_sso_live', is_shadow=True,+ expires_at=datetime.utcnow() + timedelta(minutes=5))+ ManagedDbUserService.ensure_recorded(managed, 'permanent') # not shadow++ removed = ManagedDbUserService.reap_expired_shadow_users()+ assert removed == 1+ names = {r.username for r in ManagedDatabaseUser.query.all()}+ assert names == {'sk_sso_live', 'permanent'}+ assert "DROP USER IF EXISTS 'sk_sso_dead'@'%';" in sql_log+ assert not any('sk_sso_live' in s for s in sql_log)+++# ── API ──────────────────────────────────────────────────────────────────────++def test_api_create_list_delete_user(app, client, auth_headers, managed, sql_log):+ _register_bp(app)++ resp = client.post(f'/api/v1/managed-databases/{managed.id}/users',+ headers=auth_headers, json={'username': 'api_user'})+ assert resp.status_code == 201+ body = resp.get_json()+ assert body['user']['username'] == 'api_user'+ assert body['password'] # returned once+ user_id = body['user']['id']++ resp = client.get(f'/api/v1/managed-databases/{managed.id}/users',+ headers=auth_headers)+ assert resp.status_code == 200+ users = resp.get_json()['users']+ assert any(u.get('username') == 'api_user' for u in users)+ assert all('password' not in u for u in users) # never re-exposed++ resp = client.delete(f'/api/v1/managed-databases/{managed.id}/users/{user_id}',+ headers=auth_headers)+ assert resp.status_code == 200+ assert ManagedDatabaseUser.query.count() == 0+++def test_api_create_requires_admin(app, client, managed):+ _register_bp(app)+ from flask_jwt_extended import create_access_token+ from werkzeug.security import generate_password_hash+ from app.models import User++ dev = User(email='[email protected]', username='dbudev',+ password_hash=generate_password_hash('x'),+ role=User.ROLE_DEVELOPER, is_active=True)+ db.session.add(dev)+ db.session.commit()+ headers = {'Authorization': f'Bearer {create_access_token(identity=dev.id)}'}+ resp = client.post(f'/api/v1/managed-databases/{managed.id}/users',+ headers=headers, json={'username': 'nope'})+ assert resp.status_code == 403+++def test_api_404_on_unknown_database(app, client, auth_headers):+ _register_bp(app)+ resp = client.get('/api/v1/managed-databases/99999/users', headers=auth_headers)+ assert resp.status_code == 404+ assert resp.get_json() == {'error': 'Managed database not found'}+++def test_api_bad_grants_is_400(app, client, auth_headers, managed, sql_log):+ _register_bp(app)+ resp = client.post(f'/api/v1/managed-databases/{managed.id}/users',+ headers=auth_headers,+ json={'username': 'u1', 'grants': ['SELECT; DROP']})+ assert resp.status_code == 400+ assert resp.get_json() == {'error': 'Invalid grants'}diff --git a/frontend/src/components/databases/AdminerSsoButton.jsx b/frontend/src/components/databases/AdminerSsoButton.jsxnew file mode 100644index 00000000..746fa1fd--- /dev/null+++ b/frontend/src/components/databases/AdminerSsoButton.jsx@@ -0,0 +1,62 @@+import { useState } from 'react';+import { ExternalLink } from 'lucide-react';+import api from '../../services/api';+import { useToast } from '../../contexts/ToastContext';+import { Button } from '@/components/ui/button';++// Adminer accepts a plain form POST into its login screen; submitting the+// descriptor from a hidden form means the single-use password never touches+// the URL, storage, or our own state beyond this handler.+function postToAdminer(descriptor) {+ const form = document.createElement('form');+ form.method = 'POST';+ form.action = descriptor.url;+ form.target = '_blank';+ form.rel = 'noopener';++ const fields = {+ 'auth[driver]': descriptor.driver,+ 'auth[server]': descriptor.server,+ 'auth[username]': descriptor.username,+ 'auth[password]': descriptor.password,+ 'auth[db]': descriptor.database,+ };+ Object.entries(fields).forEach(([name, value]) => {+ const input = document.createElement('input');+ input.type = 'hidden';+ input.name = name;+ input.value = value ?? '';+ form.appendChild(input);+ });++ document.body.appendChild(form);+ form.submit();+ form.remove();+}++// One-click DB admin: mints a 5-minute, single-database credential server-side+// and opens Adminer in a new tab already logged in as it.+export default function AdminerSsoButton({ databaseId, disabled = false }) {+ const toast = useToast();+ const [busy, setBusy] = useState(false);++ async function launch() {+ setBusy(true);+ try {+ const descriptor = await api.launchManagedDbSso(databaseId);+ postToAdminer(descriptor);+ toast.success('Opened Adminer with a 5-minute scoped credential');+ } catch (err) {+ toast.error(err.message || 'Failed to launch Adminer');+ } finally {+ setBusy(false);+ }+ }++ return (+ <Button type="button" size="sm" variant="outline"+ disabled={disabled || busy} onClick={launch}>+ <ExternalLink size={14} /> {busy ? 'Opening…' : 'Open in Adminer'}+ </Button>+ );+}diff --git a/frontend/src/components/databases/DbUsersPanel.jsx b/frontend/src/components/databases/DbUsersPanel.jsxnew file mode 100644index 00000000..dbc7df90--- /dev/null+++ b/frontend/src/components/databases/DbUsersPanel.jsx@@ -0,0 +1,151 @@+import { useState, useEffect, useCallback } from 'react';+import { Copy, Plus, Trash2, UserRound } from 'lucide-react';+import api from '../../services/api';+import { useToast } from '../../contexts/ToastContext';+import { useConfirm } from '../../hooks/useConfirm';+import { Button } from '@/components/ui/button';++// Users ServerKit created on a managed database (tracked rows merged with the+// live engine list). Create returns the password exactly once — it is shown+// until dismissed and never retrievable again.+export default function DbUsersPanel({ databaseId }) {+ const toast = useToast();+ const { confirm } = useConfirm();+ const [users, setUsers] = useState([]);+ const [loading, setLoading] = useState(true);+ const [creating, setCreating] = useState(false);+ const [newUsername, setNewUsername] = useState('');+ const [newGrants, setNewGrants] = useState('ALL');+ const [oneTimeSecret, setOneTimeSecret] = useState(null); // { username, password }++ const load = useCallback(async () => {+ setLoading(true);+ try {+ const data = await api.getManagedDbUsers(databaseId);+ setUsers(data?.users || []);+ } catch (err) {+ toast.error(err.message || 'Failed to load database users');+ } finally {+ setLoading(false);+ }+ }, [databaseId, toast]);++ useEffect(() => { load(); }, [load]);++ async function createUser(e) {+ e.preventDefault();+ setCreating(true);+ try {+ const grants = newGrants.split(',').map((g) => g.trim()).filter(Boolean);+ const data = await api.createManagedDbUser(databaseId, {+ username: newUsername.trim() || undefined,+ grants: grants.length ? grants : undefined,+ });+ setOneTimeSecret({ username: data.user.username, password: data.password });+ setNewUsername('');+ setNewGrants('ALL');+ await load();+ } catch (err) {+ toast.error(err.message || 'Failed to create user');+ } finally {+ setCreating(false);+ }+ }++ async function removeUser(user) {+ const ok = await confirm({+ title: `Drop user “${user.username}”?`,+ message: 'This drops the user on the database server and stops tracking it.',+ confirmText: 'Drop user',+ danger: true,+ });+ if (!ok) return;+ try {+ await api.deleteManagedDbUser(databaseId, user.id);+ toast.success('User dropped');+ await load();+ } catch (err) {+ toast.error(err.message || 'Failed to drop user');+ }+ }++ async function copySecret() {+ if (oneTimeSecret && navigator.clipboard) {+ await navigator.clipboard.writeText(oneTimeSecret.password);+ toast.success('Password copied');+ }+ }++ return (+ <div className="managed-db__users">+ {oneTimeSecret && (+ <div className="managed-db__secret">+ <span className="managed-db__meta">+ Password for <strong>{oneTimeSecret.username}</strong>:{' '}+ <code>{oneTimeSecret.password}</code> — shown once, save it now.+ </span>+ <div className="managed-db__actions">+ <Button type="button" size="sm" variant="outline" onClick={copySecret}>+ <Copy size={14} /> Copy+ </Button>+ <Button type="button" size="sm" variant="ghost"+ onClick={() => setOneTimeSecret(null)}>+ Dismiss+ </Button>+ </div>+ </div>+ )}++ {loading ? (+ <p className="managed-db__hint">Loading users…</p>+ ) : users.length === 0 ? (+ <p className="managed-db__hint">No users tracked for this database yet.</p>+ ) : (+ <div className="managed-db__list">+ {users.map((user) => (+ <div key={user.id ?? `live-${user.username}`} className="managed-db__row">+ <div className="managed-db__info">+ <strong><UserRound size={13} /> {user.username}</strong>+ <span className="managed-db__meta">+ {user.tracked === false+ ? 'exists on server, not created by ServerKit'+ : (user.grants || []).join(', ') || 'no grants recorded'}+ {user.present === false ? ' · missing on server' : ''}+ </span>+ </div>+ {user.tracked !== false && (+ <div className="managed-db__actions">+ <Button type="button" size="sm" variant="ghost"+ onClick={() => removeUser(user)}+ aria-label={`Drop user ${user.username}`}>+ <Trash2 size={14} /> Drop+ </Button>+ </div>+ )}+ </div>+ ))}+ </div>+ )}++ <form className="managed-db__user-form" onSubmit={createUser}>+ <input+ type="text"+ value={newUsername}+ onChange={(e) => setNewUsername(e.target.value)}+ placeholder="username (blank = generated)"+ aria-label="New user name"+ />+ <input+ type="text"+ value={newGrants}+ onChange={(e) => setNewGrants(e.target.value)}+ placeholder="grants, e.g. ALL or SELECT, INSERT"+ aria-label="Grants"+ />+ <Button type="submit" size="sm" variant="outline" disabled={creating}>+ <Plus size={14} /> {creating ? 'Creating…' : 'Create user'}+ </Button>+ </form>+ </div>+ );+}diff --git a/frontend/src/components/databases/ManagedDatabasesPanel.jsx b/frontend/src/components/databases/ManagedDatabasesPanel.jsxindex 1c2d0717..8f234a9e 100644--- a/frontend/src/components/databases/ManagedDatabasesPanel.jsx+++ b/frontend/src/components/databases/ManagedDatabasesPanel.jsx@@ -1,10 +1,12 @@import { useState, useEffect, useCallback } from 'react';-import { Copy, ShieldCheck, Trash2, RefreshCw, Link2 } from 'lucide-react';+import { Copy, ShieldCheck, Trash2, RefreshCw, Link2, Users } from 'lucide-react';import api from '../../services/api';import { useToast } from '../../contexts/ToastContext';import { useConfirm } from '../../hooks/useConfirm';import { Button } from '@/components/ui/button';import { Pill } from '../ds';+import AdminerSsoButton from './AdminerSsoButton';+import DbUsersPanel from './DbUsersPanel';// Durable list of the databases ServerKit tracks (provisioned or adopted),// beside the live explorer. Reveal/copy a real connection string (audited),@@ -15,6 +17,7 @@ export default function ManagedDatabasesPanel() {const [rows, setRows] = useState([]);const [loading, setLoading] = useState(true);const [busyId, setBusyId] = useState(null);+ const [usersOpenId, setUsersOpenId] = useState(null);const load = useCallback(async () => {setLoading(true);@@ -106,29 +109,42 @@ export default function ManagedDatabasesPanel() {) : (<div className="managed-db__list">{rows.map((row) => (- <div key={row.id} className="managed-db__row">- <div className="managed-db__info">- <strong>{row.name}</strong>- <span className="managed-db__meta">- {row.engine} · {row.host}:{row.port}- {row.admin_username ? ` · ${row.admin_username}` : ''}- </span>- </div>- <Pill kind={row.origin === 'provisioned' ? 'green' : 'gray'}>{row.origin}</Pill>- <div className="managed-db__actions">- <Button type="button" size="sm" variant="outline" disabled={busyId === row.id}- onClick={() => copyConnectionUri(row)}>- <Copy size={14} /> Connection string- </Button>- <Button type="button" size="sm" variant="outline" disabled={busyId === row.id}- onClick={() => protect(row)}>- <ShieldCheck size={14} /> Protect- </Button>- <Button type="button" size="sm" variant="ghost" disabled={busyId === row.id}- onClick={() => untrack(row, false)} aria-label={`Untrack ${row.name}`}>- <Trash2 size={14} /> Untrack- </Button>+ <div key={row.id} className="managed-db__item">+ <div className="managed-db__row">+ <div className="managed-db__info">+ <strong>{row.name}</strong>+ <span className="managed-db__meta">+ {row.engine} · {row.host}:{row.port}+ {row.admin_username ? ` · ${row.admin_username}` : ''}+ </span>+ </div>+ <Pill kind={row.origin === 'provisioned' ? 'green' : 'gray'}>{row.origin}</Pill>+ <div className="managed-db__actions">+ {(row.engine === 'mysql' || row.engine === 'postgresql') && (+ <AdminerSsoButton databaseId={row.id} disabled={busyId === row.id} />+ )}+ <Button type="button" size="sm" variant="outline" disabled={busyId === row.id}+ onClick={() => copyConnectionUri(row)}>+ <Copy size={14} /> Connection string+ </Button>+ <Button type="button" size="sm" variant="outline" disabled={busyId === row.id}+ onClick={() => protect(row)}>+ <ShieldCheck size={14} /> Protect+ </Button>+ {(row.engine === 'mysql' || row.engine === 'postgresql') && (+ <Button type="button" size="sm" variant="ghost" disabled={busyId === row.id}+ onClick={() => setUsersOpenId(usersOpenId === row.id ? null : row.id)}+ aria-expanded={usersOpenId === row.id}>+ <Users size={14} /> Users+ </Button>+ )}+ <Button type="button" size="sm" variant="ghost" disabled={busyId === row.id}+ onClick={() => untrack(row, false)} aria-label={`Untrack ${row.name}`}>+ <Trash2 size={14} /> Untrack+ </Button>+ </div></div>+ {usersOpenId === row.id && <DbUsersPanel databaseId={row.id} />}</div>))}</div>diff --git a/frontend/src/pages/Databases.jsx b/frontend/src/pages/Databases.jsxindex 21a7b533..e9a34d52 100644--- a/frontend/src/pages/Databases.jsx+++ b/frontend/src/pages/Databases.jsx@@ -2,7 +2,8 @@ import { useState, useEffect, useMemo, useCallback, useRef } from 'react';import {PanelLeftClose, PanelLeftOpen, Search, X, RefreshCw, Plus, Terminal,Archive, Database, Table2, Server, ChevronDown,- Trash2, DatabaseBackup, Copy, FileCode2, Lock, BookMarked,+ Trash2, DatabaseBackup, Copy, FileCode2, Lock, BookMarked, Activity,+ SlidersHorizontal,} from 'lucide-react';import api from '../services/api';import Modal from '@/components/Modal';@@ -15,6 +16,8 @@ import SourceTree from '../components/databases/SourceTree';import ConsoleTab from '../components/databases/ConsoleTab';import TableDataTab from '../components/databases/TableDataTab';import BackupsTab from '../components/databases/BackupsTab';+import ProcessListPanel from '../components/databases/ProcessListPanel';+import ConfigTunerPanel from '../components/databases/ConfigTunerPanel';import {CreateMySQLDatabaseModal, CreateMySQLUserModal,CreatePostgreSQLDatabaseModal, CreatePostgreSQLUserModal,@@ -57,6 +60,7 @@ function dockerDbNode(engine, db, i) {function TabIcon({ tab }) {if (tab.kind === 'backups') return <Archive size={13} aria-hidden="true" />;+ if (tab.kind === 'processes') return <Activity size={13} aria-hidden="true" />;if (tab.kind === 'console') return <Terminal size={13} aria-hidden="true" />;return <Table2 size={13} aria-hidden="true" />;}@@ -83,6 +87,7 @@ export default function Databases() {const [ctxMenu, setCtxMenu] = useState(null);const [showNewMenu, setShowNewMenu] = useState(false);const [showManaged, setShowManaged] = useState(false);+ const [tunerTarget, setTunerTarget] = useState(null);const [modal, setModal] = useState(null); // { type, databases }const newMenuRef = useRef(null);const didAutoExpand = useRef(false);@@ -232,6 +237,16 @@ export default function Databases() {setActiveTabId(id);}+ function openProcesses(conn, engine) {+ // One processes tab per server/container — a database's conn routes to+ // its host server, so key on engine + container rather than connKey.+ const id = `proc:${engine}:${conn.container || 'host'}`;+ const title = conn.container ? `Processes · ${conn.container}` : `Processes · ${ENGINE_META[engine]?.short || engine}`;+ setTabs((prev) => prev.some((t) => t.id === id) ? prev+ : [...prev, { id, kind: 'processes', title, conn, engine }]);+ setActiveTabId(id);+ }+function openBackups() {setTabs((prev) => prev.some((t) => t.id === 'backups') ? prev : [...prev, { id: 'backups', kind: 'backups', title: 'Backups' }]);setActiveTabId('backups');@@ -330,6 +345,7 @@ export default function Databases() {return [{ label: 'Create database', icon: Plus, onClick: () => setModal({ type: 'mysql-db' }) },{ label: 'Create user', icon: Plus, onClick: () => openUserModal('mysql') },+ { label: 'Processes', icon: Activity, onClick: () => openProcesses({ dbType: 'mysql' }, 'mysql') },{ label: 'Refresh', icon: RefreshCw, onClick: () => refresh(node) },];}@@ -337,6 +353,7 @@ export default function Databases() {return [{ label: 'Create database', icon: Plus, onClick: () => setModal({ type: 'pg-db' }) },{ label: 'Create user', icon: Plus, onClick: () => openUserModal('postgresql') },+ { label: 'Processes', icon: Activity, onClick: () => openProcesses({ dbType: 'postgresql' }, 'postgresql') },{ label: 'Refresh', icon: RefreshCw, onClick: () => refresh(node) },];}@@ -347,7 +364,14 @@ export default function Databases() {{ label: 'Refresh tables', icon: RefreshCw, onClick: () => refresh(node) },];if (node.engine === 'mysql' || node.engine === 'postgresql') {- actions.splice(1, 0, { label: 'Back up database', icon: DatabaseBackup, onClick: () => backupDatabase(node) });+ // Processes live at the server/container level; the db node+ // is just the natural place to reach them from.+ actions.splice(1, 0, { label: 'Server processes', icon: Activity, onClick: () => openProcesses(node.conn, node.engine) });+ if (node.conn?.dbType === 'docker' && node.conn.container) {+ // Curated config tuner is container-scoped (docker-only).+ actions.splice(2, 0, { label: 'Config tuner', icon: SlidersHorizontal, onClick: () => setTunerTarget({ container: node.conn.container, engine: node.engine, password: node.conn.password }) });+ }+ actions.splice(2, 0, { label: 'Back up database', icon: DatabaseBackup, onClick: () => backupDatabase(node) });actions.push({ label: 'Drop database', icon: Trash2, danger: true, onClick: () => dropDatabase(node) });}return actions;@@ -564,6 +588,14 @@ export default function Databases() {onOpenConsole={(q) => openConsole(tab.conn, tab.engine, q)}/>)}+ {tab.kind === 'processes' && (+ <ProcessListPanel+ conn={tab.conn}+ engine={tab.engine}+ active={tab.id === activeTabId}+ isAdmin={isAdmin}+ />+ )}{tab.kind === 'backups' && <BackupsTab />}</div>))@@ -626,6 +658,12 @@ export default function Databases() {<ManagedDatabasesPanel /></Modal>+ <Modal open={!!tunerTarget} onClose={() => setTunerTarget(null)} title="Config tuner" size="lg">+ {tunerTarget && (+ <ConfigTunerPanel target={tunerTarget.container} engine={tunerTarget.engine} password={tunerTarget.password} />+ )}+ </Modal>+</div>);}diff --git a/frontend/src/services/api/databases.js b/frontend/src/services/api/databases.jsindex 895feae1..6c19bd69 100644--- a/frontend/src/services/api/databases.js+++ b/frontend/src/services/api/databases.js@@ -262,3 +262,23 @@ export async function revealManagedConnectionUri(id) {export async function protectManagedDatabase(id, policy = null) {return this.request(`/databases/managed/${id}/protect`, { method: 'POST', body: { policy } });}++// Managed database users — tracked rows merged with the live engine list.+// create returns the password exactly once; it is never stored or re-exposed.+export async function getManagedDbUsers(id) {+ return this.request(`/managed-databases/${id}/users`);+}++export async function createManagedDbUser(id, data) {+ return this.request(`/managed-databases/${id}/users`, { method: 'POST', body: data });+}++export async function deleteManagedDbUser(id, userId) {+ return this.request(`/managed-databases/${id}/users/${userId}`, { method: 'DELETE' });+}++// One-click Adminer SSO — mints a 5-minute single-database credential and+// returns the launch descriptor the caller form-POSTs into Adminer.+export async function launchManagedDbSso(id) {+ return this.request(`/managed-databases/${id}/sso`, { method: 'POST' });+}diff --git a/frontend/src/styles/pages/_databases.scss b/frontend/src/styles/pages/_databases.scssindex 9b584a61..cdc23e51 100644--- a/frontend/src/styles/pages/_databases.scss+++ b/frontend/src/styles/pages/_databases.scss@@ -1038,6 +1038,12 @@ $dbx-sqlite: #3d8fd1;flex-direction: column;}+ &__item {+ border-top: 1px solid var(--border-soft);++ &:first-child { border-top: none; }+ }+&__row {display: flex;align-items: center;@@ -1046,6 +1052,49 @@ $dbx-sqlite: #3d8fd1;border-top: 1px solid var(--border-soft);&:first-child { border-top: none; }++ // Inside an __item wrapper the item owns the divider.+ .managed-db__item > & { border-top: none; }+ }++ // Per-database users panel (expanded under a row)+ &__users {+ display: flex;+ flex-direction: column;+ gap: $spacing-sm;+ padding: 0 0 $space-3 $spacing-md;+ border-left: 2px solid var(--border-soft);+ margin-bottom: $space-3;+ }++ &__secret {+ display: flex;+ align-items: center;+ justify-content: space-between;+ gap: $spacing-md;+ padding: $spacing-sm;+ border: 1px dashed var(--border-soft);+ border-radius: 6px;++ code { word-break: break-all; }+ }++ &__user-form {+ display: flex;+ gap: 6px;+ flex-wrap: wrap;+ align-items: center;++ input {+ flex: 1;+ min-width: 160px;+ padding: 6px 10px;+ font-size: 13px;+ background: var(--bg-input, transparent);+ border: 1px solid var(--border-soft);+ border-radius: 6px;+ color: var(--text);+ }}&__info {