Skip to content

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.

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.py
new file mode 100644
index 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), 200
diff --git a/backend/app/models/managed_database_user.py b/backend/app/models/managed_database_user.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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 removed
diff --git a/backend/migrations/versions/050_managed_database_users.py b/backend/migrations/versions/050_managed_database_users.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.jsx
new file mode 100644
index 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.jsx
new file mode 100644
index 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.jsx
index 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.jsx
index 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.js
index 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.scss
index 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 {