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): install any engine, because an engine is just a template
Juan Denis3070353631d1
diff --git a/backend/app/__init__.py b/backend/app/__init__.pyindex b071f102..c3937fdd 100644--- a/backend/app/__init__.py+++ b/backend/app/__init__.py@@ -182,6 +182,10 @@ def create_app(config_name=None):from app.api.databases import databases_bpapp.register_blueprint(databases_bp, url_prefix='/api/v1/databases')+ # Register blueprints - Database engine catalog (composed from templates)+ from app.api.database_engines import database_engines_bp+ app.register_blueprint(database_engines_bp, url_prefix='/api/v1/databases/engines')+# Register blueprints - Managed DB users + Adminer SSOfrom app.api.managed_db_users import managed_db_users_bpapp.register_blueprint(managed_db_users_bp, url_prefix='/api/v1/managed-databases')diff --git a/backend/app/api/apps.py b/backend/app/api/apps.pyindex e04da30f..0a828286 100644--- a/backend/app/api/apps.py+++ b/backend/app/api/apps.py@@ -56,6 +56,27 @@ def _local_compose_file(app):return app.compose_file if app.compose_file else None+def _remove_data_flag(app):+ """Should ``DELETE /apps/<id>`` take the data volumes down with the app?++ Explicit wins: ``?remove_data=`` (alias ``?volumes=``) is honored as given.+ With neither present, database engines default to PRESERVING their volumes+ -- the data is the whole point of the engine and its loss is the only+ irreversible part of an uninstall -- while every other app keeps the+ historic "remove volumes too" behavior.+ """+ raw = request.args.get('remove_data')+ if raw is None:+ raw = request.args.get('volumes')+ if raw is not None:+ return str(raw).strip().lower() in ('1', 'true', 'yes', 'on')+ try:+ from app.services.database_engine_service import is_engine_app+ return not is_engine_app(app)+ except Exception:+ return True++def _sync_manual_app_status(app):"""Update app.status from the real runtime for manual/local apps."""if app.source != 'manual':@@ -1396,17 +1417,25 @@ def delete_app(app_id):except Exception as e:cleanup_results['firewall'] = {'error': str(e)}- # For Docker apps, stop and remove containers/volumes+ # For Docker apps, stop and remove containers (and, by default, volumes).+ #+ # Database engines are the exception: destroying the data volume is the one+ # irreversible part of an uninstall, so an app installed from a template+ # carrying an `engine:` block KEEPS its volumes unless the caller explicitly+ # asks for `?remove_data=true`. Everything else keeps the historic+ # volumes=True default. `?remove_data=` (or `?volumes=`) overrides either way.+ remove_data = _remove_data_flag(app)if app.app_type == 'docker' and app.root_path:try:- # Stop and remove containers, networks, and volumes+ # Stop and remove containers, networks, and (optionally) volumesresult = DockerService.compose_down(app.root_path,- volumes=True,+ volumes=remove_data,remove_orphans=True,compose_file=_local_compose_file(app))cleanup_results['docker'] = result+ cleanup_results['data_volumes_removed'] = remove_dataexcept Exception as e:cleanup_results['docker'] = {'error': str(e)}diff --git a/backend/app/api/database_engines.py b/backend/app/api/database_engines.pynew file mode 100644index 00000000..8568fecf--- /dev/null+++ b/backend/app/api/database_engines.py@@ -0,0 +1,88 @@+"""Database engine catalog + install, prefix ``/api/v1/databases/engines``.++Deliberately thin. There is no engine model and no engine install mechanism+here: the catalog is composed from templates carrying an ``engine:`` block, and+an install delegates to the same deployment-job pipeline every other template+install uses -- so the UI can navigate straight to the deploy console.++Lifecycle (start / stop / uninstall) is app lifecycle. Use+``POST /api/v1/apps/<id>/start``, ``/stop`` and ``DELETE /api/v1/apps/<id>``+(which preserves an engine's data volumes unless ``?remove_data=true``).+"""+import logging++from flask import Blueprint, jsonify, request+from flask_jwt_extended import get_jwt_identity, jwt_required++from app.middleware.rbac import admin_required+from app.services import database_engine_service as engines+from app.services.deployment_job_service import DeploymentJobService++logger = logging.getLogger(__name__)++database_engines_bp = Blueprint('database_engines', __name__)+++@database_engines_bp.route('', methods=['GET'])+@jwt_required()+def list_database_engines():+ """The installable engine catalog plus every engine already installed.++ ``catalog`` is every available template declaring an ``engine:`` block --+ bundled, operator-authored, or pulled in by a synced template repository.+ Nothing here is hardcoded: dropping a new engine YAML into the templates+ directory is enough to make it appear.+ """+ live = request.args.get('live', 'true').lower() != 'false'+ catalog = engines.engine_catalog()+ return jsonify({+ 'catalog': catalog,+ 'installed': engines.installed_engines(live_status=live),+ # Derived from the catalog so the UI never carries its own family list.+ 'families': engines.catalog_families(catalog),+ }), 200+++@database_engines_bp.route('', methods=['POST'])+@jwt_required()+@admin_required+def install_database_engine():+ """Install an engine by installing its template.++ Answers with whatever the template pipeline returns (``job_id`` + the job),+ so the caller navigates to the deploy console exactly as it would for any+ other template install.+ """+ data = request.get_json(silent=True) or {}++ plan = engines.plan_install(+ template_id=data.get('template_id'),+ version=data.get('version'),+ instance_name=data.get('instance_name'),+ port=data.get('port'),+ expose_public=bool(data.get('expose_public', False)),+ initial_database=data.get('initial_database'),+ variables=data.get('variables') or {},+ )+ if 'error' in plan:+ status = plan.pop('status_code', 400)+ return jsonify(plan), status++ result = DeploymentJobService.install_template(+ template_id=data.get('template_id'),+ app_name=plan['app_name'],+ user_variables=plan['variables'],+ user_id=get_jwt_identity(),+ server_id=data.get('server_id') or data.get('target_server_id'),+ wait=bool(data.get('wait', False)),+ )+ if not result.get('success'):+ return jsonify(result), 400++ result['engine'] = plan['engine']+ result['app_name'] = plan['app_name']+ if plan.get('warning'):+ result['warning'] = plan['warning']++ status = (result.get('job') or {}).get('status')+ return jsonify(result), 201 if status == 'succeeded' else 202diff --git a/backend/app/api/templates.py b/backend/app/api/templates.pyindex 271baf41..c6ee1769 100644--- a/backend/app/api/templates.py+++ b/backend/app/api/templates.py@@ -79,7 +79,10 @@ def get_template(template_id):'required': var.get('required', False),'options': var.get('options', None),'auto_generated': var_type in auto_generated_types,- 'hidden': var_type == 'port' # Ports are hidden from users+ # Ports are hidden by default, but a template may say+ # otherwise -- a database engine's port is the operator's+ # decision, so its templates declare `hidden: false`.+ 'hidden': bool(var.get('hidden', var_type == 'port')),})elif isinstance(raw_vars, dict):# Old dict format: {PORT: {type: 'port', ...}, ...}@@ -94,7 +97,7 @@ def get_template(template_id):'required': var_config.get('required', False),'options': var_config.get('options', None),'auto_generated': var_type in auto_generated_types,- 'hidden': var_type == 'port'+ 'hidden': bool(var_config.get('hidden', var_type == 'port')),})return jsonify({@@ -111,6 +114,9 @@ def get_template(template_id):'documentation': template.get('documentation'),'website': template.get('website'),'variables': variables,+ # Present only for database-engine templates; the Databases install+ # drawer reads it to know which variable is the port / password.+ 'engine': TemplateService.engine_metadata(template),'has_compose': 'compose' in template,'has_dockerfile': 'dockerfile' in template,'scripts': list(template.get('scripts', {}).keys()),@@ -200,10 +206,55 @@ def catalog_schema():{'token': '${SERVICE_BASE64_<NAME>}','description': 'Base64 of a freshly generated secret.'},],+ # The optional `engine:` block is what makes a template installable from+ # the Databases page. It is described here rather than hardcoded in the+ # UI so a new engine is a YAML file, never a code change.+ 'engine_block': {+ 'optional': True,+ 'description': 'Presence of a top-level `engine:` block marks the template '+ 'as an installable database engine and lists it in Databases.',+ 'families': list(TemplateService.ENGINE_FAMILIES),+ 'protocols': list(TemplateService.ENGINE_PROTOCOLS),+ 'fields': [+ {'field': 'family', 'required': False,+ 'description': 'Grouping used by the catalog family filter.'},+ {'field': 'protocol', 'required': False,+ 'description': "Client adapter that can introspect it. 'none' is valid "+ 'and means the tree offers no browsing for this engine.'},+ {'field': 'default_port', 'required': False,+ 'description': "The engine's conventional port, shown as a hint."},+ {'field': 'admin_user', 'required': False,+ 'description': 'Bootstrap superuser created by the image.'},+ {'field': 'admin_password_var', 'required': False,+ 'description': "Name of the `variables` entry (type: password) holding "+ 'the admin secret, so the UI can surface it once.'},+ {'field': 'database_var', 'required': False,+ 'description': 'Variable that seeds an initial database, if the image supports one.'},+ {'field': 'port_var', 'required': False,+ 'default': TemplateService.ENGINE_DEFAULT_PORT_VAR,+ 'description': 'Variable holding the published host port.'},+ {'field': 'bind_var', 'required': False,+ 'default': TemplateService.ENGINE_DEFAULT_BIND_VAR,+ 'description': f'Variable holding the bind address. Defaults to '+ f'{TemplateService.ENGINE_PRIVATE_BIND} (private); the installer '+ f'sets {TemplateService.ENGINE_PUBLIC_BIND} only on an explicit '+ 'expose_public opt-in.'},+ {'field': 'unit', 'required': False,+ 'description': 'What a "table" is called here (collections, keys, buckets, ...).'},+ {'field': 'client', 'required': False,+ 'description': 'CLI client hint shown in the UI.'},+ {'field': 'data_path', 'required': False,+ 'description': 'Container-side data directory the named volume mounts onto.'},+ {'field': 'versions', 'required': False,+ 'description': 'Selectable image versions. Defaults to the template version.'},+ ],+ },'notes': ['Magic tokens need no variables: entry; they are resolved at install ''and persisted to .env / surfaced post-install.','<NAME> groups related tokens: the same <NAME> resolves to a consistent value.',+ 'Unknown top-level keys are tolerated by the validator; `engine` is now a '+ 'known block and is carried through the catalog listing and repo index.',],}return jsonify(schema), 200diff --git a/backend/app/services/database_engine_service.py b/backend/app/services/database_engine_service.pynew file mode 100644index 00000000..a4e7983c--- /dev/null+++ b/backend/app/services/database_engine_service.py@@ -0,0 +1,319 @@+"""Database engines, composed from the template catalog.++There is no engine model, no engine table and no engine install mechanism. A+database engine **is** an app template that carries a top-level ``engine:``+block, and installing one **is** installing that template through the existing+deployment-job pipeline. Adding CockroachDB -- or anything else -- is dropping a+YAML file into ``backend/templates/`` or syncing a template repository. No+Python changes, ever.++This module only composes:++* :func:`engine_catalog` -- engine templates + how many instances each has+* :func:`installed_engines` -- ``Application`` rows born from an engine+ template, with live container status and their engine metadata resolved+* :func:`plan_install` -- turns the Databases install form into the variables+ the template pipeline already understands++Safety rules that live here (the rest are enforced by the templates themselves):++1. **Private by default.** The bind-address variable is set from the explicit+ ``expose_public`` flag *after* merging caller-supplied variables, so a+ handcrafted ``variables`` payload cannot quietly publish an engine.+3. **Port collisions are refused** before a job is created, with the next free+ port in the 409 body.+6. **Images come from the template's compose only.** ``version`` is checked+ against the template's own ``engine.versions`` allow-list, so the tag can+ never be attacker-chosen.++Rule 5 (never destroy the data volume implicitly) is enforced at the app-delete+route: see ``_remove_data_flag`` in ``app/api/apps.py``.+"""+import json+import logging+import os+import re+from typing import Dict, List, Optional++from app.services.template_service import TemplateService++logger = logging.getLogger(__name__)++# Which non-secret install variables are safe to echo back on a listing.+# Anything else (passwords, tokens, master keys) is never read out of the+# recorded install info.+_PUBLIC_VARIABLE_KEYS = ('BIND_ADDRESS', 'PORT', 'HTTP_PORT', 'DB_NAME')+++# ── template <-> application mapping ─────────────────────────────────────────+def app_template_id(app) -> Optional[str]:+ """Which template an ``Application`` was installed from, or ``None``.++ Primary source is the panel's template config (written by the install+ finalizer). Falls back to the ``.serverkit-template.json`` dropped in the+ app directory, so an app survives a lost/reset config file.+ """+ try:+ installed = TemplateService.get_config().get('installed', {}) or {}+ record = installed.get(str(getattr(app, 'id', '')))+ if record and record.get('template_id'):+ return record['template_id']+ except Exception:+ pass+ info = _install_info(app)+ return (info or {}).get('template_id')+++def _install_info(app) -> Optional[Dict]:+ """Parsed ``.serverkit-template.json`` from the app directory, or ``None``."""+ root = getattr(app, 'root_path', None)+ if not root:+ return None+ path = os.path.join(root, '.serverkit-template.json')+ try:+ with open(path, 'r', encoding='utf-8') as fh:+ data = json.load(fh)+ return data if isinstance(data, dict) else None+ except Exception:+ return None+++def is_engine_app(app) -> bool:+ """True when ``app`` was installed from a template declaring ``engine:``."""+ template_id = app_template_id(app)+ if not template_id:+ return False+ result = TemplateService.get_template(template_id)+ return bool(result.get('success')+ and TemplateService.is_engine_template(result['template']))+++# ── catalog ──────────────────────────────────────────────────────────────────+def engine_catalog() -> List[Dict]:+ """Every template carrying an ``engine:`` block, local or synced.++ Enriched with ``installed_count`` / ``instances`` so the catalog drawer can+ show an "Already running" section without a second round trip.+ """+ from app.models import Application++ counts: Dict[str, List[int]] = {}+ for app in Application.query.all():+ template_id = app_template_id(app)+ if template_id:+ counts.setdefault(template_id, []).append(app.id)++ catalog = []+ for entry in TemplateService.list_engine_templates():+ instances = counts.get(entry['id'], [])+ item = dict(entry)+ item.pop('filepath', None) # a server path is not the UI's business+ item['installed_count'] = len(instances)+ item['instances'] = instances+ catalog.append(item)+ return catalog+++def catalog_families(catalog: List[Dict]) -> List[str]:+ """Families actually present in the catalog, in the canonical order.++ Derived from the response so the UI never hardcodes a family list.+ """+ present = {(e.get('engine') or {}).get('family') for e in catalog}+ return [f for f in TemplateService.ENGINE_FAMILIES if f in present]+++# ── installed instances ──────────────────────────────────────────────────────+def installed_engines(live_status: bool = True) -> List[Dict]:+ """Applications installed from an engine template, with their metadata."""+ from app.models import Application++ results = []+ for app in Application.query.order_by(Application.created_at.asc()).all():+ template_id = app_template_id(app)+ if not template_id:+ continue+ fetched = TemplateService.get_template(template_id)+ if not fetched.get('success'):+ continue+ template = fetched['template']+ engine = TemplateService.engine_metadata(template)+ if not engine:+ continue+ results.append(_describe_instance(app, template_id, template, engine,+ live_status=live_status))+ return results+++def _describe_instance(app, template_id, template, engine, live_status=True) -> Dict:+ variables = ((_install_info(app) or {}).get('variables') or {})+ bind = variables.get(engine.get('bind_var') or TemplateService.ENGINE_DEFAULT_BIND_VAR)+ data = {+ 'app_id': app.id,+ 'name': app.name,+ 'status': app.status,+ 'port': app.port,+ 'server_id': app.server_id,+ 'root_path': app.root_path,+ 'created_at': app.created_at.isoformat() if app.created_at else None,+ 'template_id': template_id,+ 'template_name': template.get('name'),+ 'template_version': template.get('version'),+ 'icon': template.get('icon'),+ 'engine': engine,+ # Explicitly derived, not guessed: anything other than a loopback bind+ # means the port is reachable off-host.+ 'exposed_public': bool(bind) and bind not in ('127.0.0.1', 'localhost', '::1'),+ # Never echo the admin secret; say only that one exists.+ 'has_secret': bool(engine.get('admin_password_var')+ and variables.get(engine['admin_password_var'])),+ 'variables': {k: v for k, v in variables.items() if k in _PUBLIC_VARIABLE_KEYS},+ }+ data['container'] = _container_state(app) if live_status else None+ return data+++def _container_state(app) -> Optional[Dict]:+ """Live container state, or ``None`` when Docker cannot answer."""+ from app.services.docker_service import DockerService+ ref = getattr(app, 'container_id', None) or app.name+ try:+ state = DockerService.get_container_state(ref)+ except Exception:+ return None+ if not state:+ return None+ return {'running': bool(state.get('running')), 'state': state.get('state')}+++# ── install ──────────────────────────────────────────────────────────────────+def _err(message: str, status_code: int = 400, **extra) -> Dict:+ payload = {'error': message, 'status_code': status_code}+ payload.update(extra)+ return payload+++def _slug(value: str) -> str:+ return re.sub(r'[^a-z0-9-]+', '-', (value or '').strip().lower()).strip('-')+++def default_instance_name(template_id: str) -> str:+ """``postgresql``, then ``postgresql-2``… — the first name not taken."""+ from app.models import Application++ base = _slug(template_id) or 'engine'+ taken = {a.name for a in Application.query.all()}+ if base not in taken:+ return base+ for suffix in range(2, 100):+ candidate = f'{base}-{suffix}'+ if candidate not in taken:+ return candidate+ return f'{base}-{os.urandom(3).hex()}'+++def plan_install(*, template_id, version=None, instance_name=None, port=None,+ expose_public=False, initial_database=None, variables=None) -> Dict:+ """Validate the Databases install form and render it into template variables.++ Returns ``{'app_name', 'variables', 'template', 'engine', 'warning'?}`` or an+ error dict carrying ``status_code``. Performs no side effects -- the caller+ hands the result straight to the template install pipeline.+ """+ if not template_id:+ return _err('template_id is required', 400)++ fetched = TemplateService.get_template(template_id)+ if not fetched.get('success'):+ return _err(f"Template '{template_id}' not found", 404)++ template = fetched['template']+ engine = TemplateService.engine_metadata(template)+ if not engine:+ # Safety rule 6: this route installs engines, and an engine is defined+ # by its template. Anything else goes through the normal template flow.+ return _err(f"Template '{template_id}' is not a database engine "+ "(it declares no `engine:` block)", 400)++ declared = _declared_variables(template)+ resolved: Dict[str, str] = dict(variables or {})++ # Version -> image tag, checked against the template's own allow-list so a+ # caller can never inject an arbitrary image reference.+ if version not in (None, ''):+ version = str(version)+ if version not in engine['versions']:+ return _err(f"Version '{version}' is not offered by {template.get('name')}", 400,+ versions=engine['versions'])+ version_var = (template.get('engine') or {}).get('version_var') or 'IMAGE_TAG'+ if version_var not in declared:+ return _err(f"{template.get('name')} does not support choosing a version", 400)+ resolved[version_var] = version++ # Instance name == app name; the pipeline's own rules apply.+ app_name = _slug(instance_name) if instance_name else default_instance_name(template_id)+ from app.utils.slug import validate_app_name+ valid, error = validate_app_name(app_name, min_length=3)+ if not valid:+ return _err(error, 400)++ # Safety rule 3: refuse a busy port up front and name a free one.+ if port not in (None, ''):+ try:+ port = int(port)+ except (TypeError, ValueError):+ return _err('port must be an integer', 400)+ if not 1 <= port <= 65535:+ return _err('port must be between 1 and 65535', 400)+ if not TemplateService._port_is_free(port):+ return _err(f'Port {port} is already in use', 409, port=port,+ suggested_port=TemplateService._find_available_port(port + 1))+ port_var = engine.get('port_var') or TemplateService.ENGINE_DEFAULT_PORT_VAR+ if port_var not in declared:+ return _err(f"{template.get('name')} does not expose a configurable port", 400)+ resolved[port_var] = str(port)++ if initial_database not in (None, ''):+ database_var = engine.get('database_var')+ if not database_var:+ return _err(f"{template.get('name')} does not support an initial database", 400)+ resolved[database_var] = str(initial_database)++ # Safety rule 1, applied LAST so a caller-supplied `variables` entry can+ # never override the explicit private/public decision.+ warning = None+ if expose_public and not engine.get('admin_password_var'):+ # Some engines have no credentials to expose at all -- CockroachDB's+ # single-node mode runs `--insecure`. For those the loopback bind is the+ # ONLY access control, so publishing one to every interface is refused+ # outright rather than warned about.+ return _err(f"{template.get('name')} runs without authentication, so it "+ 'cannot be exposed publicly. Keep it bound to localhost and '+ 'reach it over a tunnel, or move it to a credentialed '+ 'configuration first.', 400)+ bind_var = engine.get('bind_var') or TemplateService.ENGINE_DEFAULT_BIND_VAR+ if bind_var in declared:+ resolved[bind_var] = (TemplateService.ENGINE_PUBLIC_BIND if expose_public+ else TemplateService.ENGINE_PRIVATE_BIND)+ elif expose_public:+ return _err(f"{template.get('name')} cannot be exposed publicly "+ "(its template declares no bind-address variable)", 400)++ if expose_public:+ warning = (f"{template.get('name')} will accept connections from any network "+ 'interface. Anyone who can reach this host can attempt to '+ 'authenticate against it — restrict it with the firewall, or '+ 'keep it private and reach it over a tunnel.')++ return {'app_name': app_name, 'variables': resolved, 'template': template,+ 'engine': engine, 'warning': warning}+++def _declared_variables(template: Dict) -> set:+ """Names of the variables a template declares (list or dict form)."""+ raw = template.get('variables', [])+ if isinstance(raw, list):+ return {v.get('name') for v in raw if isinstance(v, dict) and v.get('name')}+ if isinstance(raw, dict):+ return set(raw.keys())+ return set()diff --git a/backend/app/services/template_service.py b/backend/app/services/template_service.pyindex 6942f32d..ef643d34 100644--- a/backend/app/services/template_service.py+++ b/backend/app/services/template_service.py@@ -48,6 +48,47 @@ class TemplateService:# Template schema versionSCHEMA_VERSION = '1.0'+ # ==================================================================+ # The `engine:` block — what makes a template a database engine+ # ------------------------------------------------------------------+ # A template becomes installable from the Databases page purely by+ # carrying a top-level ``engine:`` mapping. Presence of the block is the+ # ONLY marker; there is no allow-list of engine ids anywhere in Python, so+ # shipping a new engine (CockroachDB, DuckDB, whatever) is dropping a YAML+ # file into ``backend/templates/`` or syncing a template repository.+ #+ # engine:+ # family: Relational # see ENGINE_FAMILIES+ # protocol: postgresql # see ENGINE_PROTOCOLS+ # default_port: 26257+ # admin_user: root+ # admin_password_var: DB_PASSWORD # which `variables` entry is the secret+ # database_var: DB_NAME # optional: seeds an initial database+ # port_var: PORT # optional: which variable is the port+ # bind_var: BIND_ADDRESS # optional: private-vs-public bind+ # unit: tables+ # client: cockroach sql+ # data_path: /cockroach/cockroach-data+ #+ # ``protocol: none`` is legitimate: the engine installs and is listed, but+ # the database tree offers no introspection for it. That is honest — better+ # than pretending we can browse it.+ # ==================================================================+ ENGINE_FAMILIES = (+ 'Relational', 'Document', 'Key-value', 'Time-series',+ 'Analytics', 'Search', 'Graph',+ )+ # Which client adapter (if any) can introspect the engine once it is up.+ ENGINE_PROTOCOLS = ('postgresql', 'mysql', 'mongodb', 'redis', 'none')++ # Conventional variable names, used when the block does not name its own.+ ENGINE_DEFAULT_PORT_VAR = 'PORT'+ ENGINE_DEFAULT_BIND_VAR = 'BIND_ADDRESS'+ # Safety rule 1: an engine is reachable only from the host unless the+ # operator explicitly opts out.+ ENGINE_PRIVATE_BIND = '127.0.0.1'+ ENGINE_PUBLIC_BIND = '0.0.0.0'+@classmethoddef get_config(cls) -> Dict:"""Get template configuration."""@@ -123,10 +164,75 @@ class TemplateService:if not isinstance(var_config, dict):errors.append(f"Variable {var_name} must be a dictionary")+ # Validate the optional `engine:` block. Unknown top-level keys were+ # already tolerated (this validator checks required fields, it does not+ # reject extras) -- what was missing is that a MALFORMED engine block+ # went unnoticed and then silently produced a broken catalog card.+ if 'engine' in template:+ errors.extend(cls._engine_block_errors(template['engine']))+if errors:return {'valid': False, 'errors': errors}return {'valid': True}+ @classmethod+ def _engine_block_errors(cls, engine: Any) -> List[str]:+ """Hard errors in an ``engine:`` block (shape only, never opinions)."""+ if not isinstance(engine, dict):+ return ["'engine' must be a mapping"]+ errors = []+ family = engine.get('family')+ if family is not None and family not in cls.ENGINE_FAMILIES:+ errors.append(+ f"engine.family '{family}' is not one of: {', '.join(cls.ENGINE_FAMILIES)}")+ protocol = engine.get('protocol')+ if protocol is not None and protocol not in cls.ENGINE_PROTOCOLS:+ errors.append(+ f"engine.protocol '{protocol}' is not one of: {', '.join(cls.ENGINE_PROTOCOLS)}")+ port = engine.get('default_port')+ if port is not None:+ try:+ if not 1 <= int(port) <= 65535:+ raise ValueError+ except (TypeError, ValueError):+ errors.append('engine.default_port must be a port number (1-65535)')+ return errors++ @classmethod+ def is_engine_template(cls, template: Dict) -> bool:+ """True when a template declares itself a database engine."""+ return isinstance(template, dict) and isinstance(template.get('engine'), dict)++ @classmethod+ def engine_metadata(cls, template: Dict) -> Optional[Dict]:+ """Normalized ``engine:`` block, or ``None`` for a non-engine template.++ Fills in the conventional variable names so every consumer sees the same+ keys, and resolves ``versions`` from the template's own ``version`` plus+ any ``engine.versions`` the author offers. Nothing here is hardcoded per+ engine -- it is all read off the YAML.+ """+ if not cls.is_engine_template(template):+ return None+ engine = dict(template['engine'])+ versions = engine.get('versions')+ if not isinstance(versions, list) or not versions:+ versions = [template.get('version')] if template.get('version') else []+ return {+ 'family': engine.get('family'),+ 'protocol': engine.get('protocol') or 'none',+ 'default_port': engine.get('default_port'),+ 'admin_user': engine.get('admin_user'),+ 'admin_password_var': engine.get('admin_password_var'),+ 'database_var': engine.get('database_var'),+ 'port_var': engine.get('port_var') or cls.ENGINE_DEFAULT_PORT_VAR,+ 'bind_var': engine.get('bind_var') or cls.ENGINE_DEFAULT_BIND_VAR,+ 'unit': engine.get('unit'),+ 'client': engine.get('client'),+ 'data_path': engine.get('data_path'),+ 'versions': [str(v) for v in versions],+ }+@classmethoddef parse_template(cls, template_path: str) -> Dict:"""Parse a template file."""@@ -469,6 +575,21 @@ class TemplateService:_check_tokens(scan_target)+ # Engine templates: shape errors already came from validate_template+ # above. Here we add the soft checks -- a block that names variables+ # which don't exist would install, but the Databases UI could not find+ # the password field or the port field.+ if cls.is_engine_template(entry):+ engine = entry['engine']+ declared = {name for name, _ in var_items if name}+ for key in ('admin_password_var', 'database_var', 'port_var', 'bind_var'):+ var_name = engine.get(key)+ if var_name and var_name not in declared:+ warnings.append(+ f"engine.{key} references '{var_name}', which is not a declared variable")+ if not engine.get('family'):+ warnings.append('engine block has no family; it will not match a family filter')+return {'valid': not errors, 'errors': errors, 'warnings': warnings}@classmethod@@ -592,6 +713,31 @@ class TemplateService:import randomreturn random.randint(10000, 60000)+ @classmethod+ def _port_is_free(cls, port) -> bool:+ """True when nothing -- app row, container, or live socket -- holds+ ``port``. Same three sources as :meth:`_find_available_port`, asked+ about one specific port instead of scanning."""+ import socket+ try:+ port = int(port)+ except (TypeError, ValueError):+ return False+ if not 1 <= port <= 65535:+ return False+ if port in (cls._get_database_used_ports() | cls._get_docker_used_ports()):+ return False+ try:+ test_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)+ test_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)+ test_sock.bind(('127.0.0.1', port))+ test_sock.close()+ return True+ except OSError:+ return False+ except Exception:+ return False+@classmethoddef _get_database_used_ports(cls) -> set:"""Get all ports assigned to applications in the database."""@@ -710,10 +856,30 @@ class TemplateService:'url': repo.get('url'),'branch': repo.get('branch', 'main'),}+ # A database engine declares itself with a top-level+ # `engine:` block. This listing is a fixed projection,+ # so without carrying the block through, the Databases+ # catalog could never see an engine without re-parsing+ # every YAML file.+ engine = cls.engine_metadata(template)+ if engine:+ entry['engine'] = enginetemplates.append(entry)return templates+ @classmethod+ def list_engine_templates(cls) -> List[Dict]:+ """Every available template carrying an ``engine:`` block.++ This is what the Databases engine catalog renders. It is derived+ entirely from the template sources -- drop a new engine YAML into+ ``backend/templates/`` (or sync a repository that ships one) and it+ appears here with no code change.+ """+ return [t for t in cls.list_all_templates()+ if isinstance(t.get('engine'), dict)]+@classmethoddef build_repo_index(cls, repo_name: str = 'serverkit-official') -> Dict:"""Build the ``index.json`` document that describes the locally-bundled@@ -725,8 +891,9 @@ class TemplateService:host the ``templates/*.yaml`` files plus this ``index.json``. LetsPrompture Hub & friends ship template updates without a panel release."""- templates = [- {+ templates = []+ for t in cls.list_local_templates():+ entry = {'id': t['id'],'name': t.get('name'),'version': t.get('version'),@@ -734,8 +901,11 @@ class TemplateService:'icon': t.get('icon'),'categories': t.get('categories', []),}- for t in cls.list_local_templates()- ]+ # Carried in the index so a panel that syncs this repo can list the+ # engine catalog without fetching all 100+ template files first.+ if isinstance(t.get('engine'), dict):+ entry['engine'] = t['engine']+ templates.append(entry)return {'name': repo_name,'schema_version': cls.SCHEMA_VERSION,@@ -1037,7 +1207,17 @@ class TemplateService:var_type = var_config.get('type', 'string')if var_type == 'port':- variables[var_name] = cls.generate_value(var_config)+ # Ports are auto-assigned by default (template defaults are+ # never trusted). An explicitly REQUESTED port is honored, but+ # only after confirming it is actually free -- so the caller+ # still can never be handed a port that is already bound. The+ # Databases engine installer relies on this to make its+ # documented `port` parameter real rather than advisory.+ requested = (user_variables or {}).get(var_name)+ if requested and cls._port_is_free(requested):+ variables[var_name] = str(requested)+ else:+ variables[var_name] = cls.generate_value(var_config)elif user_variables and var_name in user_variables and user_variables[var_name]:variables[var_name] = user_variables[var_name]elif var_config.get('required', False) and var_name not in user_variables:diff --git a/backend/templates/clickhouse.yaml b/backend/templates/clickhouse.yamlnew file mode 100644index 00000000..b4b70bee--- /dev/null+++ b/backend/templates/clickhouse.yaml@@ -0,0 +1,97 @@+id: clickhouse+name: ClickHouse+version: "24.3"+description: Columnar OLAP database for event data and analytical queries over billions of rows+icon: https://serverkit.ai/imgs/template-icons/clickhouse.svg+categories:+ - database+ - analytics+website: https://clickhouse.com+documentation: https://clickhouse.com/docs++engine:+ family: Analytics+ protocol: none+ default_port: 8123+ admin_user: default+ admin_password_var: DB_PASSWORD+ database_var: DB_NAME+ port_var: PORT+ bind_var: BIND_ADDRESS+ unit: tables+ client: clickhouse-client+ data_path: /var/lib/clickhouse+ version_var: IMAGE_TAG+ versions:+ - "24.3"+ - "23.8"++variables:+ - name: IMAGE_TAG+ type: string+ default: "24.3"+ hidden: true+ description: Image tag; constrained to engine.versions by the installer+ - name: PORT+ type: port+ default: "8123"+ hidden: false+ description: Host port for the HTTP interface+ - name: NATIVE_PORT+ type: port+ default: "9000"+ hidden: false+ description: Host port for the native TCP protocol+ - name: BIND_ADDRESS+ type: string+ default: 127.0.0.1+ hidden: true+ description: Address the ports bind to. 127.0.0.1 keeps the engine private.+ - name: DB_PASSWORD+ type: password+ length: 28+ description: Password for the default ClickHouse user+ - name: DB_NAME+ type: string+ default: default+ description: Initial database to create++compose:+ services:+ app:+ image: clickhouse/clickhouse-server:${IMAGE_TAG}+ container_name: ${APP_NAME}+ restart: unless-stopped+ ports:+ - "${BIND_ADDRESS}:${PORT}:8123"+ - "${BIND_ADDRESS}:${NATIVE_PORT}:9000"+ environment:+ # The entrypoint writes a users.d override from these. Without+ # CLICKHOUSE_PASSWORD the `default` user has an EMPTY password.+ CLICKHOUSE_USER: default+ CLICKHOUSE_PASSWORD: "${DB_PASSWORD}"+ CLICKHOUSE_DB: "${DB_NAME}"+ CLICKHOUSE_DEFAULT_ACCESS_MANAGEMENT: "1"+ # ClickHouse needs a high file-descriptor limit or it logs warnings and+ # degrades under load.+ ulimits:+ nofile:+ soft: 262144+ hard: 262144+ volumes:+ - clickhouse-data:/var/lib/clickhouse++ volumes:+ clickhouse-data:++ports:+ - port: "${PORT}"+ protocol: http+ description: HTTP interface+ - port: "${NATIVE_PORT}"+ protocol: tcp+ description: Native protocol++requirements:+ memory: 2GB+ storage: 20GBdiff --git a/backend/templates/cockroachdb.yaml b/backend/templates/cockroachdb.yamlnew file mode 100644index 00000000..33a44836--- /dev/null+++ b/backend/templates/cockroachdb.yaml@@ -0,0 +1,93 @@+id: cockroachdb+name: CockroachDB+version: "24.1"+description: Distributed SQL database that speaks the PostgreSQL wire protocol, with survivable single-node mode for self-hosting+icon: https://serverkit.ai/imgs/template-icons/cockroachdb.svg+categories:+ - database+ - sql+ - distributed+website: https://www.cockroachlabs.com+documentation: https://www.cockroachlabs.com/docs/++engine:+ family: Relational+ # Cockroach speaks pgwire, so a PostgreSQL client can introspect it.+ protocol: postgresql+ default_port: 26257+ admin_user: root+ # Deliberately NO admin_password_var -- see the note on the compose command.+ database_var: DB_NAME+ port_var: PORT+ bind_var: BIND_ADDRESS+ unit: tables+ client: cockroach sql+ data_path: /cockroach/cockroach-data+ version_var: IMAGE_TAG+ versions:+ - "24.1"+ - "23.2"++variables:+ - name: IMAGE_TAG+ type: string+ default: "24.1"+ hidden: true+ description: Image tag; constrained to engine.versions by the installer+ - name: PORT+ type: port+ default: "26257"+ hidden: false+ description: Host port to publish the SQL endpoint on+ - name: ADMIN_UI_PORT+ type: port+ default: "26258"+ hidden: false+ description: Host port for the DB Console (web UI)+ - name: BIND_ADDRESS+ type: string+ default: 127.0.0.1+ hidden: true+ description: Address the ports bind to. 127.0.0.1 keeps the engine private.+ - name: DB_NAME+ type: string+ default: defaultdb+ description: Initial database to create++compose:+ services:+ app:+ # Cockroach Labs publishes rolling `latest-v<major.minor>` tags.+ image: cockroachdb/cockroach:latest-v${IMAGE_TAG}+ container_name: ${APP_NAME}+ restart: unless-stopped+ ports:+ - "${BIND_ADDRESS}:${PORT}:26257"+ - "${BIND_ADDRESS}:${ADMIN_UI_PORT}:8080"+ environment:+ # Creates the database at first start. COCKROACH_USER/COCKROACH_PASSWORD+ # are intentionally NOT set: password auth requires a secure (TLS)+ # cluster with generated certificates, which single-node self-hosting+ # does not set up. `--insecure` therefore means NO authentication -- the+ # 127.0.0.1 bind above is what keeps this safe, so do not expose this+ # engine publicly without first moving it to a certificate-backed+ # secure cluster.+ COCKROACH_DATABASE: "${DB_NAME}"+ command: start-single-node --insecure+ volumes:+ - cockroachdb-data:/cockroach/cockroach-data++ volumes:+ cockroachdb-data:++ports:+ - port: "${PORT}"+ protocol: postgresql+ description: SQL (PostgreSQL wire protocol)+ - port: "${ADMIN_UI_PORT}"+ protocol: http+ description: DB Console++requirements:+ memory: 2GB+ storage: 10GBdiff --git a/backend/templates/couchdb.yaml b/backend/templates/couchdb.yamlnew file mode 100644index 00000000..e0e9caf9--- /dev/null+++ b/backend/templates/couchdb.yaml@@ -0,0 +1,75 @@+id: couchdb+name: CouchDB+version: "3.3"+description: Document database with an HTTP API and multi-master replication for offline-first apps+icon: https://serverkit.ai/imgs/template-icons/couchdb.svg+categories:+ - database+ - nosql+website: https://couchdb.apache.org+documentation: https://docs.couchdb.org/++engine:+ family: Document+ protocol: none+ default_port: 5984+ admin_user: admin+ admin_password_var: DB_PASSWORD+ port_var: PORT+ bind_var: BIND_ADDRESS+ unit: documents+ client: curl+ data_path: /opt/couchdb/data+ version_var: IMAGE_TAG+ versions:+ - "3.3"+ - "3.2"++variables:+ - name: IMAGE_TAG+ type: string+ default: "3.3"+ hidden: true+ description: Image tag; constrained to engine.versions by the installer+ - name: PORT+ type: port+ default: "5984"+ hidden: false+ description: Host port to publish CouchDB on+ - name: BIND_ADDRESS+ type: string+ default: 127.0.0.1+ hidden: true+ description: Address the port binds to. 127.0.0.1 keeps the engine private.+ - name: DB_PASSWORD+ type: password+ length: 28+ description: Password for the CouchDB admin user++compose:+ services:+ app:+ image: couchdb:${IMAGE_TAG}+ container_name: ${APP_NAME}+ restart: unless-stopped+ ports:+ - "${BIND_ADDRESS}:${PORT}:5984"+ environment:+ # Without BOTH of these the node comes up in "admin party" mode, where+ # any client can create and delete databases.+ COUCHDB_USER: admin+ COUCHDB_PASSWORD: "${DB_PASSWORD}"+ volumes:+ - couchdb-data:/opt/couchdb/data++ volumes:+ couchdb-data:++ports:+ - port: "${PORT}"+ protocol: http+ description: CouchDB HTTP API++requirements:+ memory: 512MB+ storage: 5GBdiff --git a/backend/templates/index.json b/backend/templates/index.jsonindex b300c76e..7072e8cc 100644--- a/backend/templates/index.json+++ b/backend/templates/index.json@@ -1,716 +1,38 @@{- "version": "1.0.0",- "updated_at": "2026-06-23",+ "name": "serverkit-official",+ "schema_version": "1.0",+ "generated_at": "2026-07-25T20:06:08.123735",+ "count": 117,"templates": [- {- "id": "uptime-kuma",- "name": "Uptime Kuma",- "version": "1.23",- "description": "A fancy self-hosted monitoring tool for websites and services",- "categories": [- "monitoring",- "devops"- ]- },- {- "id": "portainer",- "name": "Portainer",- "version": "2.19",- "description": "Lightweight Docker management UI with container visualization",- "categories": [- "devops",- "docker",- "management"- ]- },- {- "id": "ghost",- "name": "Ghost",- "version": "5.75",- "description": "Professional publishing platform for blogs and newsletters",- "categories": [- "cms",- "blog",- "publishing"- ]- },- {- "id": "nextcloud",- "name": "Nextcloud",- "version": "28.0",- "description": "Self-hosted productivity platform with file sync and collaboration",- "categories": [- "storage",- "collaboration",- "productivity"- ]- },- {- "id": "gitea",- "name": "Gitea",- "version": "1.21",- "description": "Lightweight self-hosted Git service",- "categories": [- "devops",- "git",- "development"- ]- },- {- "id": "nginx-proxy-manager",- "name": "Nginx Proxy Manager",- "version": "2.10",- "description": "Easy-to-use reverse proxy with SSL management",- "categories": [- "networking",- "proxy",- "ssl"- ]- },- {- "id": "grafana",- "name": "Grafana",- "version": "10.2",- "description": "Open-source analytics and interactive visualization platform for metrics, logs, and traces",- "categories": [- "monitoring",- "analytics",- "visualization"- ]- },- {- "id": "prometheus",- "name": "Prometheus",- "version": "2.48",- "description": "Open-source monitoring and alerting toolkit designed for reliability and scalability",- "categories": [- "monitoring",- "metrics",- "alerting"- ]- },- {- "id": "netdata",- "name": "Netdata",- "version": "1.44",- "description": "Real-time performance and health monitoring for systems and applications",- "categories": [- "monitoring",- "metrics",- "realtime"- ]- },- {- "id": "loki",- "name": "Grafana Loki",- "version": "2.9",- "description": "Horizontally scalable, highly available log aggregation system inspired by Prometheus",- "categories": [- "monitoring",- "logging",- "observability"- ]- },- {- "id": "jaeger",- "name": "Jaeger",- "version": "1.52",- "description": "Open-source distributed tracing system for monitoring and troubleshooting microservices",- "categories": [- "monitoring",- "tracing",- "observability"- ]- },- {- "id": "jenkins",- "name": "Jenkins",- "version": "2.426",- "description": "Leading open-source automation server for building, deploying, and automating projects",- "categories": [- "devops",- "ci-cd",- "automation"- ]- },- {- "id": "drone",- "name": "Drone CI",- "version": "2.22",- "description": "Container-native continuous integration platform with simple pipeline configuration",- "categories": [- "devops",- "ci-cd",- "docker"- ]- },- {- "id": "gitlab-runner",- "name": "GitLab Runner",- "version": "16.6",- "description": "Application that works with GitLab CI/CD to run jobs in a pipeline",- "categories": [- "devops",- "ci-cd",- "gitlab"- ]- },- {- "id": "sonarqube",- "name": "SonarQube",- "version": "10.3",- "description": "Continuous inspection of code quality and security vulnerabilities",- "categories": [- "devops",- "code-quality",- "security"- ]- },- {- "id": "registry",- "name": "Docker Registry",- "version": "2.8",- "description": "Private Docker container image registry for storing and distributing container images",- "categories": [- "devops",- "docker",- "registry"- ]- },- {- "id": "vault",- "name": "HashiCorp Vault",- "version": "1.15",- "description": "Secrets management and data protection platform for securing sensitive data",- "categories": [- "devops",- "security",- "secrets"- ]- },- {- "id": "wordpress",- "name": "WordPress",- "version": "6.4",- "description": "World's most popular content management system for blogs and websites",- "categories": [- "cms",- "blog",- "website"- ]- },- {- "id": "wordpress-external-db",- "name": "WordPress (External Database)",- "version": "6.4",- "description": "WordPress CMS connecting to an existing external MySQL database. Use this for dev/prod setups sharing the same database with different table prefixes.",- "categories": [- "cms",- "blog",- "website",- "development"- ]- },- {- "id": "strapi",- "name": "Strapi",- "version": "4.15",- "description": "Open-source headless CMS with customizable API and admin panel",- "categories": [- "cms",- "headless",- "api"- ]- },- {- "id": "directus",- "name": "Directus",- "version": "10.8",- "description": "Open-source data platform with instant REST and GraphQL API for any SQL database",- "categories": [- "cms",- "headless",- "api",- "database"- ]- },- {- "id": "payload",- "name": "Payload CMS",- "version": "2.5",- "description": "Modern TypeScript headless CMS with powerful admin panel and customization",- "categories": [- "cms",- "headless",- "typescript"- ]- },- {- "id": "grav",- "name": "Grav CMS",- "version": "1.7",- "description": "Modern flat-file CMS that is fast, simple, and flexible",- "categories": [- "cms",- "flat-file",- "blog"- ]- },- {- "id": "jellyfin",- "name": "Jellyfin",- "version": "10.8",- "description": "Free and open-source media server for streaming movies, TV shows, music, and more",- "categories": [- "media",- "streaming",- "entertainment"- ]- },- {- "id": "plex",- "name": "Plex Media Server",- "version": "1.32",- "description": "Organize and stream your personal media collection to any device",- "categories": [- "media",- "streaming",- "entertainment"- ]- },- {- "id": "photoprism",- "name": "PhotoPrism",- "version": "231128",- "description": "AI-powered photo management application with face recognition and auto-tagging",- "categories": [- "media",- "photos",- "ai"- ]- },- {- "id": "immich",- "name": "Immich",- "version": "1.91",- "description": "High-performance self-hosted photo and video backup solution with mobile apps",- "categories": [- "media",- "photos",- "backup"- ]- },- {- "id": "navidrome",- "name": "Navidrome",- "version": "0.50",- "description": "Modern music server and streamer compatible with Subsonic/Airsonic",- "categories": [- "media",- "music",- "streaming"- ]- },- {- "id": "rocketchat",- "name": "Rocket.Chat",- "version": "6.5",- "description": "Open-source team communication platform with chat, video, and file sharing",- "categories": [- "collaboration",- "chat",- "communication"- ]- },- {- "id": "mattermost",- "name": "Mattermost",- "version": "9.2",- "description": "Open-source Slack alternative for secure team collaboration and messaging",- "categories": [- "collaboration",- "chat",- "communication"- ]- },- {- "id": "matrix-synapse",- "name": "Matrix Synapse",- "version": "1.98",- "description": "Decentralized communication server for secure, federated messaging",- "categories": [- "collaboration",- "chat",- "federation"- ]- },- {- "id": "jitsi",- "name": "Jitsi Meet",- "version": "9111",- "description": "Secure, fully featured, and completely free video conferencing",- "categories": [- "collaboration",- "video",- "conferencing"- ]- },- {- "id": "minio",- "name": "MinIO",- "version": "2024-01",- "description": "High-performance, S3-compatible object storage for cloud-native applications",- "categories": [- "storage",- "s3",- "cloud"- ]- },- {- "id": "seafile",- "name": "Seafile",- "version": "11.0",- "description": "Open-source file sync and share platform with built-in collaboration",- "categories": [- "storage",- "sync",- "collaboration"- ]- },- {- "id": "filebrowser",- "name": "File Browser",- "version": "2.27",- "description": "Web-based file manager with upload, download, and file sharing features",- "categories": [- "storage",- "files",- "management"- ]- },- {- "id": "syncthing",- "name": "Syncthing",- "version": "1.27",- "description": "Continuous file synchronization for decentralized, peer-to-peer sync",- "categories": [- "storage",- "sync",- "backup"- ]- },- {- "id": "duplicati",- "name": "Duplicati",- "version": "2.0",- "description": "Free backup software to store encrypted backups online",- "categories": [- "storage",- "backup",- "encryption"- ]- },- {- "id": "bookstack",- "name": "BookStack",- "version": "23.12",- "description": "Simple, self-hosted platform for organizing and storing information",- "categories": [- "productivity",- "wiki",- "documentation"- ]- },- {- "id": "wikijs",- "name": "Wiki.js",- "version": "2.5",- "description": "Modern and powerful wiki app built on Node.js",- "categories": [- "productivity",- "wiki",- "documentation"- ]- },- {- "id": "outline",- "name": "Outline",- "version": "0.74",- "description": "Beautiful, real-time collaborative team wiki and knowledge base",- "categories": [- "productivity",- "wiki",- "collaboration"- ]- },- {- "id": "excalidraw",- "name": "Excalidraw",- "version": "0.17",- "description": "Virtual whiteboard for sketching hand-drawn like diagrams",- "categories": [- "productivity",- "diagrams",- "whiteboard"- ]- },- {- "id": "n8n",- "name": "n8n",- "version": "1.22",- "description": "Extendable workflow automation tool for connecting apps and services",- "categories": [- "productivity",- "automation",- "integration"- ]- },- {- "id": "vaultwarden",- "name": "Vaultwarden",- "version": "1.30",- "description": "Lightweight Bitwarden-compatible password manager server",- "categories": [- "security",- "passwords",- "privacy"- ]- },- {- "id": "authelia",- "name": "Authelia",- "version": "4.37",- "description": "Authentication and authorization server providing 2FA and SSO",- "categories": [- "security",- "authentication",- "sso"- ]- },- {- "id": "keycloak",- "name": "Keycloak",- "version": "23.0",- "description": "Open-source identity and access management for modern applications",- "categories": [- "security",- "authentication",- "sso"- ]- },- {- "id": "crowdsec",- "name": "CrowdSec",- "version": "1.6",- "description": "Collaborative security engine for detecting and blocking threats",- "categories": [- "security",- "firewall",- "threat-detection"- ]- },- {- "id": "phpmyadmin",- "name": "phpMyAdmin",- "version": "5.2",- "description": "Web-based MySQL and MariaDB administration tool",- "categories": [- "database",- "mysql",- "management"- ]- },- {- "id": "pgadmin",- "name": "pgAdmin 4",- "version": "8.2",- "description": "Web-based PostgreSQL administration and development platform",- "categories": [- "database",- "postgresql",- "management"- ]- },- {- "id": "redis-commander",- "name": "Redis Commander",- "version": "0.8",- "description": "Web-based Redis management tool for viewing and editing data",- "categories": [- "database",- "redis",- "management"- ]- },- {- "id": "mongo-express",- "name": "Mongo Express",- "version": "1.0",- "description": "Web-based MongoDB admin interface for managing databases and collections",- "categories": [- "database",- "mongodb",- "management"- ]- },- {- "id": "homeassistant",- "name": "Home Assistant",- "version": "2024.1",- "description": "Open-source home automation platform with focus on local control and privacy",- "categories": [- "home-automation",- "iot",- "smart-home"- ]- },- {- "id": "nodered",- "name": "Node-RED",- "version": "3.1",- "description": "Flow-based programming tool for wiring together hardware devices and APIs",- "categories": [- "home-automation",- "automation",- "iot"- ]- },- {- "id": "mosquitto",- "name": "Eclipse Mosquitto",- "version": "2.0",- "description": "Lightweight MQTT message broker for IoT and home automation",- "categories": [- "home-automation",- "iot",- "messaging"- ]- },- {- "id": "zigbee2mqtt",- "name": "Zigbee2MQTT",- "version": "1.35",- "description": "Bridge Zigbee devices to MQTT without proprietary bridges or gateways",- "categories": [- "home-automation",- "iot",- "zigbee"- ]- },- {- "id": "code-server",- "name": "Code Server",- "version": "4.20",- "description": "VS Code in the browser with full IDE features and extensions support",- "categories": [- "development",- "ide",- "productivity"- ]- },- {- "id": "traefik",- "name": "Traefik",- "version": "3.0",- "description": "Modern HTTP reverse proxy and load balancer with automatic HTTPS",- "categories": [- "networking",- "proxy",- "ssl"- ]- },- {- "id": "caddy",- "name": "Caddy",- "version": "2.7",- "description": "Fast, multi-platform web server with automatic HTTPS",- "categories": [- "networking",- "proxy",- "ssl"- ]- },- {- "id": "plausible",- "name": "Plausible Analytics",- "version": "2.0",- "description": "Privacy-friendly, lightweight alternative to Google Analytics",- "categories": [- "analytics",- "privacy",- "monitoring"- ]- },- {- "id": "umami",- "name": "Umami",- "version": "2.9",- "description": "Simple, fast, privacy-focused alternative to Google Analytics",- "categories": [- "analytics",- "privacy",- "monitoring"- ]- },- {- "id": "php-app",- "name": "PHP Application",- "version": "8.3",- "description": "Custom PHP application with Apache. Supports PHP 8.0-8.3. Perfect for Laravel, WordPress themes, or any PHP project.",- "categories": [- "development",- "web",- "custom"- ]- },- {- "id": "flask-hello-world",- "name": "Flask - Hello World",- "version": "1.0",- "description": "Simple Flask app for testing and debugging. Shows server info, port, and connection status. No database needed.",- "categories": [- "development",- "api",- "testing"- ]- },- {- "id": "python-app",- "name": "Python Application",- "version": "3.12",- "description": "Custom Python application. Supports Python 3.9-3.12. Perfect for Flask, FastAPI, Django, or any Python project.",- "categories": [- "development",- "api",- "custom"- ]- },- {- "id": "node-app",- "name": "Node.js Application",- "version": "20",- "description": "Custom Node.js application. Supports Node 18-21. Perfect for Express, Next.js, or any Node.js project.",- "categories": [- "development",- "api",- "custom"- ]- },{"id": "actualbudget","name": "Actual Budget","version": "1.0","description": "Privacy-first personal budgeting app using envelope budgeting with optional bank sync.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBhdGggZD0iTTIxIDEyVjdINWEyIDIgMCAwIDEgMC00aDE0djQiLz48cGF0aCBkPSJNMyA1djE0YTIgMiAwIDAgMCAyIDJoMTZ2LTUiLz48cGF0aCBkPSJNMTggMTJhMiAyIDAgMCAwIDAgNGg0di00eiIvPjwvc3ZnPg==","categories": ["finance","productivity"]},+ {+ "id": "agentsite",+ "name": "AgentSite",+ "version": "1.0",+ "description": "AI-powered website builder with multi-agent orchestration, deployed straight from its Git repository.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSJjdXJyZW50Q29sb3IiIHN0cm9rZS13aWR0aD0iMiIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIj48cmVjdCB4PSIzIiB5PSIxMSIgd2lkdGg9IjE4IiBoZWlnaHQ9IjEwIiByeD0iMiIvPjxjaXJjbGUgY3g9IjEyIiBjeT0iNSIgcj0iMiIvPjxwYXRoIGQ9Ik0xMiA3djQiLz48cGF0aCBkPSJNOCAxNmguMDEiLz48cGF0aCBkPSJNMTYgMTZoLjAxIi8+PC9zdmc+",+ "categories": [+ "ai",+ "website",+ "deployment"+ ]+ },{"id": "anythingllm","name": "AnythingLLM","version": "1.0","description": "All-in-one private ChatGPT-style app with built-in RAG, AI agents, and document workspaces.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHJlY3QgeD0iMyIgeT0iMTEiIHdpZHRoPSIxOCIgaGVpZ2h0PSIxMCIgcng9IjIiLz48Y2lyY2xlIGN4PSIxMiIgY3k9IjUiIHI9IjIiLz48cGF0aCBkPSJNMTIgN3Y0Ii8+PGNpcmNsZSBjeD0iOCIgY3k9IjE2IiByPSIxIi8+PGNpcmNsZSBjeD0iMTYiIGN5PSIxNiIgcj0iMSIvPjwvc3ZnPg==","categories": ["ai","llm",@@ -723,16 +45,30 @@"name": "Audiobookshelf","version": "1.0","description": "Self-hosted server for managing and streaming your audiobooks, podcasts, and ebooks.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBhdGggZD0iTTMgMTh2LTZhOSA5IDAgMCAxIDE4IDB2NiIvPjxwYXRoIGQ9Ik0yMSAxOWEyIDIgMCAwIDEtMiAyaC0xYTIgMiAwIDAgMS0yLTJ2LTNhMiAyIDAgMCAxIDItMmgzek0zIDE5YTIgMiAwIDAgMCAyIDJoMWEyIDIgMCAwIDAgMi0ydi0zYTIgMiAwIDAgMC0yLTJIM3oiLz48L3N2Zz4=","categories": ["media","audiobooks"]},+ {+ "id": "authelia",+ "name": "Authelia",+ "version": "4.37",+ "description": "Authentication and authorization server providing 2FA and SSO",+ "icon": "https://serverkit.ai/imgs/template-icons/authelia.png",+ "categories": [+ "security",+ "authentication",+ "sso"+ ]+ },{"id": "authentik","name": "Authentik","version": "1.0","description": "Open-source identity provider for single sign-on with OIDC, SAML, and LDAP.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBhdGggZD0iTTEyIDIyczgtNCA4LTEwVjVsLTgtMy04IDN2N2MwIDYgOCAxMCA4IDEweiIvPjwvc3ZnPg==","categories": ["security","identity",@@ -744,15 +80,41 @@"name": "Beszel","version": "1.0","description": "Lightweight server monitoring hub with historical metrics and alerts.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBvbHlsaW5lIHBvaW50cz0iMjIgMTIgMTggMTIgMTUgMjEgOSAzIDYgMTIgMiAxMiIvPjwvc3ZnPg==","categories": ["monitoring"]},+ {+ "id": "bookstack",+ "name": "BookStack",+ "version": "23.12",+ "description": "Simple, self-hosted platform for organizing and storing information",+ "icon": "https://serverkit.ai/imgs/template-icons/bookstack.png",+ "categories": [+ "productivity",+ "wiki",+ "documentation"+ ]+ },+ {+ "id": "caddy",+ "name": "Caddy",+ "version": "2.7",+ "description": "Fast, multi-platform web server with automatic HTTPS",+ "icon": "https://serverkit.ai/imgs/template-icons/caddy.svg",+ "categories": [+ "networking",+ "proxy",+ "ssl"+ ]+ },{"id": "calibre-web","name": "Calibre-Web","version": "1.0","description": "Clean web interface for browsing, reading, and downloading books from a Calibre ebook library.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBhdGggZD0iTTQgMTkuNUEyLjUgMi41IDAgMCAxIDYuNSAxN0gyMCIvPjxwYXRoIGQ9Ik02LjUgMkgyMHYyMEg2LjVBMi41IDIuNSAwIDAgMSA0IDE5LjV2LTE1QTIuNSAyLjUgMCAwIDEgNi41IDJ6Ii8+PC9zdmc+","categories": ["media","ebooks",@@ -764,6 +126,7 @@"name": "Chatwoot","version": "1.0","description": "Open-source customer engagement suite with live chat and a shared inbox.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PGNpcmNsZSBjeD0iMTIiIGN5PSIxMiIgcj0iMTAiLz48Y2lyY2xlIGN4PSIxMiIgY3k9IjEyIiByPSI0Ii8+PGxpbmUgeDE9IjQuOTMiIHkxPSI0LjkzIiB4Mj0iOS4xNyIgeTI9IjkuMTciLz48bGluZSB4MT0iMTQuODMiIHkxPSIxNC44MyIgeDI9IjE5LjA3IiB5Mj0iMTkuMDciLz48bGluZSB4MT0iMTQuODMiIHkxPSI5LjE3IiB4Mj0iMTkuMDciIHkyPSI0LjkzIi8+PGxpbmUgeDE9IjQuOTMiIHkxPSIxOS4wNyIgeDI9IjkuMTciIHkyPSIxNC44MyIvPjwvc3ZnPg==","categories": ["business","support",@@ -775,38 +138,224 @@"name": "Chroma","version": "1.0","description": "Open-source vector database for embeddings and semantic search in AI and RAG applications.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PGNpcmNsZSBjeD0iNiIgY3k9IjciIHI9IjEuNSIvPjxjaXJjbGUgY3g9IjE3IiBjeT0iNiIgcj0iMS41Ii8+PGNpcmNsZSBjeD0iOSIgY3k9IjEzIiByPSIxLjUiLz48Y2lyY2xlIGN4PSIxNSIgY3k9IjE1IiByPSIxLjUiLz48Y2lyY2xlIGN4PSI2IiBjeT0iMTgiIHI9IjEuNSIvPjxjaXJjbGUgY3g9IjE5IiBjeT0iMTciIHI9IjEuNSIvPjwvc3ZnPg==","categories": ["ai","database","search"]},+ {+ "id": "clickhouse",+ "name": "ClickHouse",+ "version": "24.3",+ "description": "Columnar OLAP database for event data and analytical queries over billions of rows",+ "icon": "https://serverkit.ai/imgs/template-icons/clickhouse.svg",+ "categories": [+ "database",+ "analytics"+ ],+ "engine": {+ "family": "Analytics",+ "protocol": "none",+ "default_port": 8123,+ "admin_user": "default",+ "admin_password_var": "DB_PASSWORD",+ "database_var": "DB_NAME",+ "port_var": "PORT",+ "bind_var": "BIND_ADDRESS",+ "unit": "tables",+ "client": "clickhouse-client",+ "data_path": "/var/lib/clickhouse",+ "versions": [+ "24.3",+ "23.8"+ ]+ }+ },+ {+ "id": "cockroachdb",+ "name": "CockroachDB",+ "version": "24.1",+ "description": "Distributed SQL database that speaks the PostgreSQL wire protocol, with survivable single-node mode for self-hosting",+ "icon": "https://serverkit.ai/imgs/template-icons/cockroachdb.svg",+ "categories": [+ "database",+ "sql",+ "distributed"+ ],+ "engine": {+ "family": "Relational",+ "protocol": "postgresql",+ "default_port": 26257,+ "admin_user": "root",+ "admin_password_var": null,+ "database_var": "DB_NAME",+ "port_var": "PORT",+ "bind_var": "BIND_ADDRESS",+ "unit": "tables",+ "client": "cockroach sql",+ "data_path": "/cockroach/cockroach-data",+ "versions": [+ "24.1",+ "23.2"+ ]+ }+ },+ {+ "id": "code-server",+ "name": "Code Server",+ "version": "4.20",+ "description": "VS Code in the browser with full IDE features and extensions support",+ "icon": "https://serverkit.ai/imgs/template-icons/code-server.ico",+ "categories": [+ "development",+ "ide",+ "productivity"+ ]+ },+ {+ "id": "couchdb",+ "name": "CouchDB",+ "version": "3.3",+ "description": "Document database with an HTTP API and multi-master replication for offline-first apps",+ "icon": "https://serverkit.ai/imgs/template-icons/couchdb.svg",+ "categories": [+ "database",+ "nosql"+ ],+ "engine": {+ "family": "Document",+ "protocol": "none",+ "default_port": 5984,+ "admin_user": "admin",+ "admin_password_var": "DB_PASSWORD",+ "database_var": null,+ "port_var": "PORT",+ "bind_var": "BIND_ADDRESS",+ "unit": "documents",+ "client": "curl",+ "data_path": "/opt/couchdb/data",+ "versions": [+ "3.3",+ "3.2"+ ]+ }+ },+ {+ "id": "crowdsec",+ "name": "CrowdSec",+ "version": "1.6",+ "description": "Collaborative security engine for detecting and blocking threats",+ "icon": "https://serverkit.ai/imgs/template-icons/crowdsec.png",+ "categories": [+ "security",+ "firewall",+ "threat-detection"+ ]+ },+ {+ "id": "directus",+ "name": "Directus",+ "version": "10.8",+ "description": "Open-source data platform with instant REST and GraphQL API for any SQL database",+ "icon": "https://serverkit.ai/imgs/template-icons/directus.ico",+ "categories": [+ "cms",+ "headless",+ "api",+ "database"+ ]+ },{"id": "documenso","name": "Documenso","version": "1.0","description": "Open-source document signing platform for sending and signing documents online.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBhdGggZD0iTTEyIDE5bDctNyAzIDMtNyA3LTMtM3oiLz48cGF0aCBkPSJNMTggMTNsLTEuNS03LjVMMiAybDMuNSAxNC41TDEzIDE4bDUtNXoiLz48cGF0aCBkPSJNMiAybDcuNTg2IDcuNTg2Ii8+PGNpcmNsZSBjeD0iMTEiIGN5PSIxMSIgcj0iMiIvPjwvc3ZnPg==","categories": ["business","documents","productivity"]},+ {+ "id": "drone",+ "name": "Drone CI",+ "version": "2.22",+ "description": "Container-native continuous integration platform with simple pipeline configuration",+ "icon": "https://serverkit.ai/imgs/template-icons/drone.svg",+ "categories": [+ "devops",+ "ci-cd",+ "docker"+ ]+ },+ {+ "id": "duplicati",+ "name": "Duplicati",+ "version": "2.0",+ "description": "Free backup software to store encrypted backups online",+ "icon": "https://serverkit.ai/imgs/template-icons/duplicati.png",+ "categories": [+ "storage",+ "backup",+ "encryption"+ ]+ },+ {+ "id": "excalidraw",+ "name": "Excalidraw",+ "version": "0.17",+ "description": "Virtual whiteboard for sketching hand-drawn like diagrams",+ "icon": "https://serverkit.ai/imgs/template-icons/excalidraw.png",+ "categories": [+ "productivity",+ "diagrams",+ "whiteboard"+ ]+ },+ {+ "id": "filebrowser",+ "name": "File Browser",+ "version": "2.27",+ "description": "Web-based file manager with upload, download, and file sharing features",+ "icon": "https://serverkit.ai/imgs/template-icons/filebrowser.svg",+ "categories": [+ "storage",+ "files",+ "management"+ ]+ },{"id": "firefly-iii","name": "Firefly III","version": "1.0","description": "Self-hosted personal finance manager for budgeting, accounts, and money tracking.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PGxpbmUgeDE9IjEyIiB5MT0iMSIgeDI9IjEyIiB5Mj0iMjMiLz48cGF0aCBkPSJNMTcgNUg5LjVhMy41IDMuNSAwIDAgMCAwIDdoNWEzLjUgMy41IDAgMCAxIDAgN0g2Ii8+PC9zdmc+","categories": ["finance","productivity"]},+ {+ "id": "flask-hello-world",+ "name": "Flask - Hello World",+ "version": "1.0",+ "description": "Simple Flask app for testing and debugging. Shows server info, port, and connection status. No database needed.",+ "icon": "https://serverkit.ai/imgs/template-icons/flask-hello-world.ico",+ "categories": [+ "development",+ "api",+ "testing"+ ]+ },{"id": "flowise","name": "Flowise","version": "1.0","description": "Low-code drag-and-drop builder for LLM agents and chains.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHJlY3QgeD0iMyIgeT0iMyIgd2lkdGg9IjYiIGhlaWdodD0iNiIgcng9IjEiLz48cmVjdCB4PSIxNSIgeT0iMTUiIHdpZHRoPSI2IiBoZWlnaHQ9IjYiIHJ4PSIxIi8+PHBhdGggZD0iTTkgNmg2YTIgMiAwIDAgMSAyIDJ2NyIvPjwvc3ZnPg==","categories": ["ai","llm",@@ -819,20 +368,159 @@"name": "FreshRSS","version": "1.0","description": "Free, self-hosted RSS and Atom feed aggregator for following news and websites in one place.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBhdGggZD0iTTQgMTFhOSA5IDAgMCAxIDkgOSIvPjxwYXRoIGQ9Ik00IDRhMTYgMTYgMCAwIDEgMTYgMTYiLz48Y2lyY2xlIGN4PSI1IiBjeT0iMTkiIHI9IjEiLz48L3N2Zz4=","categories": ["news","rss","productivity"]},+ {+ "id": "ghost",+ "name": "Ghost",+ "version": "5.75",+ "description": "Professional publishing platform for blogs and newsletters",+ "icon": "https://serverkit.ai/imgs/template-icons/ghost.ico",+ "categories": [+ "cms",+ "blog",+ "publishing"+ ]+ },+ {+ "id": "gitea",+ "name": "Gitea",+ "version": "1.21",+ "description": "Lightweight self-hosted Git service",+ "icon": "https://serverkit.ai/imgs/template-icons/gitea.svg",+ "categories": [+ "devops",+ "git",+ "development"+ ]+ },+ {+ "id": "gitlab-runner",+ "name": "GitLab Runner",+ "version": "16.6",+ "description": "Application that works with GitLab CI/CD to run jobs in a pipeline",+ "icon": "https://serverkit.ai/imgs/template-icons/gitlab-runner.png",+ "categories": [+ "devops",+ "ci-cd",+ "gitlab"+ ]+ },{"id": "gotify","name": "Gotify","version": "1.0","description": "Self-hosted push notification server with Android client support.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiPjxwYXRoIGQ9Ik0xOCA4QTYgNiAwIDAgMCA2IDhjMCA3LTMgOS0zIDloMTJzLTMtMi0zLTl6Ii8+PHBhdGggZD0iTTEwLjMgMjFhMiAyIDAgMCAwIDMuNCAwIi8+PC9zdmc+",+ "categories": [+ "notifications",+ "messaging"+ ]+ },+ {+ "id": "grafana",+ "name": "Grafana",+ "version": "10.2",+ "description": "Open-source analytics and interactive visualization platform for metrics, logs, and traces",+ "icon": "https://serverkit.ai/imgs/template-icons/grafana.svg",+ "categories": [+ "monitoring",+ "analytics",+ "visualization"+ ]+ },+ {+ "id": "grav",+ "name": "Grav CMS",+ "version": "1.7",+ "description": "Modern flat-file CMS that is fast, simple, and flexible",+ "icon": "https://serverkit.ai/imgs/template-icons/grav.png",+ "categories": [+ "cms",+ "flat-file",+ "blog"+ ]+ },+ {+ "id": "homeassistant",+ "name": "Home Assistant",+ "version": "2024.1",+ "description": "Open-source home automation platform with focus on local control and privacy",+ "icon": "https://serverkit.ai/imgs/template-icons/homeassistant.png",+ "categories": [+ "home-automation",+ "iot",+ "smart-home"+ ]+ },+ {+ "id": "immich",+ "name": "Immich",+ "version": "1.91",+ "description": "High-performance self-hosted photo and video backup solution with mobile apps",+ "icon": "https://serverkit.ai/imgs/template-icons/immich.svg",+ "categories": [+ "media",+ "photos",+ "backup"+ ]+ },+ {+ "id": "influxdb",+ "name": "InfluxDB",+ "version": "2.7",+ "description": "Purpose-built time-series database for metrics, sensors and monitoring data",+ "icon": "https://serverkit.ai/imgs/template-icons/influxdb.svg",+ "categories": [+ "database",+ "timeseries",+ "monitoring"+ ],+ "engine": {+ "family": "Time-series",+ "protocol": "none",+ "default_port": 8086,+ "admin_user": "admin",+ "admin_password_var": "DB_PASSWORD",+ "database_var": "DB_NAME",+ "port_var": "PORT",+ "bind_var": "BIND_ADDRESS",+ "unit": "buckets",+ "client": "influx",+ "data_path": "/var/lib/influxdb2",+ "versions": [+ "2.7",+ "2.6"+ ]+ }+ },+ {+ "id": "jaeger",+ "name": "Jaeger",+ "version": "1.52",+ "description": "Open-source distributed tracing system for monitoring and troubleshooting microservices",+ "icon": "https://serverkit.ai/imgs/template-icons/jaeger.png",+ "categories": [+ "monitoring",+ "tracing",+ "observability"+ ]+ },+ {+ "id": "jellyfin",+ "name": "Jellyfin",+ "version": "10.8",+ "description": "Free and open-source media server for streaming movies, TV shows, music, and more",+ "icon": "https://serverkit.ai/imgs/template-icons/jellyfin.svg","categories": [- "notifications",- "messaging"+ "media",+ "streaming",+ "entertainment"]},{@@ -840,26 +528,65 @@"name": "Jellyseerr","version": "1.0","description": "Media request and discovery portal for Jellyfin/Plex and the PVR apps",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHJlY3QgeD0iMiIgeT0iMiIgd2lkdGg9IjIwIiBoZWlnaHQ9IjIwIiByeD0iMi4xOCIvPjxsaW5lIHgxPSI3IiB5MT0iMiIgeDI9IjciIHkyPSIyMiIvPjxsaW5lIHgxPSIxNyIgeTE9IjIiIHgyPSIxNyIgeTI9IjIyIi8+PGxpbmUgeDE9IjIiIHkxPSIxMiIgeDI9IjIyIiB5Mj0iMTIiLz48bGluZSB4MT0iMiIgeTE9IjciIHgyPSI3IiB5Mj0iNyIvPjxsaW5lIHgxPSIyIiB5MT0iMTciIHgyPSI3IiB5Mj0iMTciLz48bGluZSB4MT0iMTciIHkxPSIxNyIgeDI9IjIyIiB5Mj0iMTciLz48bGluZSB4MT0iMTciIHkxPSI3IiB4Mj0iMjIiIHkyPSI3Ii8+PC9zdmc+","categories": ["media","automation"]},+ {+ "id": "jenkins",+ "name": "Jenkins",+ "version": "2.426",+ "description": "Leading open-source automation server for building, deploying, and automating projects",+ "icon": "https://serverkit.ai/imgs/template-icons/jenkins.svg",+ "categories": [+ "devops",+ "ci-cd",+ "automation"+ ]+ },+ {+ "id": "jitsi",+ "name": "Jitsi Meet",+ "version": "9111",+ "description": "Secure, fully featured, and completely free video conferencing",+ "icon": "https://serverkit.ai/imgs/template-icons/jitsi.ico",+ "categories": [+ "collaboration",+ "video",+ "conferencing"+ ]+ },{"id": "karakeep","name": "Karakeep","version": "1.0","description": "Self-hosted bookmark-everything app (formerly Hoarder) that saves links, notes, and images with AI tagging and full-text search.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBhdGggZD0iTTE5IDIxbC03LTUtNyA1VjVhMiAyIDAgMCAxIDItMmgxMGEyIDIgMCAwIDEgMiAyeiIvPjwvc3ZnPg==","categories": ["productivity","bookmarks"]},+ {+ "id": "keycloak",+ "name": "Keycloak",+ "version": "23.0",+ "description": "Open-source identity and access management for modern applications",+ "icon": "https://serverkit.ai/imgs/template-icons/keycloak.svg",+ "categories": [+ "security",+ "authentication",+ "sso"+ ]+ },{"id": "langflow","name": "Langflow","version": "1.0","description": "Visual framework for building multi-agent and RAG applications.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHJlY3QgeD0iMyIgeT0iMyIgd2lkdGg9IjYiIGhlaWdodD0iNiIgcng9IjEiLz48cmVjdCB4PSIxNSIgeT0iMTUiIHdpZHRoPSI2IiBoZWlnaHQ9IjYiIHJ4PSIxIi8+PHBhdGggZD0iTTkgNmg2YTIgMiAwIDAgMSAyIDJ2NyIvPjwvc3ZnPg==","categories": ["ai","llm",@@ -872,6 +599,7 @@"name": "LibreChat","version": "1.0","description": "Open-source multi-model chat UI (OpenAI, Anthropic, Google, local) with conversation search.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBhdGggZD0iTTIxIDExLjVhOC4zOCA4LjM4IDAgMCAxLS45IDMuOCA4LjUgOC41IDAgMCAxLTcuNiA0LjcgOC4zOCA4LjM4IDAgMCAxLTMuOC0uOUwzIDIxbDEuOS01LjdhOC4zOCA4LjM4IDAgMCAxLS45LTMuOCA4LjUgOC41IDAgMCAxIDQuNy03LjYgOC4zOCA4LjM4IDAgMCAxIDMuOC0uOWguNWE4LjQ4IDguNDggMCAwIDEgOCA4eiIvPjwvc3ZnPg==","categories": ["ai","llm",@@ -883,6 +611,7 @@"name": "linkding","version": "1.0","description": "Minimal, fast self-hosted bookmark manager.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBhdGggZD0iTTE5IDIxbC03LTUtNyA1VjVhMiAyIDAgMCAxIDItMmgxMGEyIDIgMCAwIDEgMiAyeiIvPjwvc3ZnPg==","categories": ["productivity","bookmarks"@@ -893,27 +622,110 @@"name": "LiteLLM","version": "1.0","description": "OpenAI-compatible proxy and gateway that routes requests across 100+ LLM providers.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PGNpcmNsZSBjeD0iNiIgY3k9IjYiIHI9IjMiLz48Y2lyY2xlIGN4PSIxOCIgY3k9IjYiIHI9IjMiLz48Y2lyY2xlIGN4PSIxMiIgY3k9IjE4IiByPSIzIi8+PHBhdGggZD0iTTYgOXYyYTIgMiAwIDAgMCAyIDJoOGEyIDIgMCAwIDAgMi0yVjlNMTIgMTV2MCIvPjwvc3ZnPg==","categories": ["ai","llm","gateway"]},+ {+ "id": "loki",+ "name": "Grafana Loki",+ "version": "2.9",+ "description": "Horizontally scalable, highly available log aggregation system inspired by Prometheus",+ "icon": "https://serverkit.ai/imgs/template-icons/loki.svg",+ "categories": [+ "monitoring",+ "logging",+ "observability"+ ]+ },+ {+ "id": "mariadb",+ "name": "MariaDB",+ "version": "11.4",+ "description": "Community-developed MySQL fork -- a drop-in relational database with a faster release cadence",+ "icon": "https://serverkit.ai/imgs/template-icons/mariadb.svg",+ "categories": [+ "database",+ "sql"+ ],+ "engine": {+ "family": "Relational",+ "protocol": "mysql",+ "default_port": 3307,+ "admin_user": "root",+ "admin_password_var": "DB_PASSWORD",+ "database_var": "DB_NAME",+ "port_var": "PORT",+ "bind_var": "BIND_ADDRESS",+ "unit": "tables",+ "client": "mariadb",+ "data_path": "/var/lib/mysql",+ "versions": [+ "11.4",+ "10.11"+ ]+ }+ },+ {+ "id": "matrix-synapse",+ "name": "Matrix Synapse",+ "version": "1.98",+ "description": "Decentralized communication server for secure, federated messaging",+ "icon": "https://serverkit.ai/imgs/template-icons/matrix-synapse.svg",+ "categories": [+ "collaboration",+ "chat",+ "federation"+ ]+ },+ {+ "id": "mattermost",+ "name": "Mattermost",+ "version": "9.2",+ "description": "Open-source Slack alternative for secure team collaboration and messaging",+ "icon": "https://serverkit.ai/imgs/template-icons/mattermost.png",+ "categories": [+ "collaboration",+ "chat",+ "communication"+ ]+ },{"id": "meilisearch","name": "Meilisearch","version": "1.0","description": "Lightning-fast, typo-tolerant search engine that many apps rely on for instant full-text search.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PGNpcmNsZSBjeD0iMTEiIGN5PSIxMSIgcj0iOCIvPjxsaW5lIHgxPSIyMSIgeTE9IjIxIiB4Mj0iMTYuNjUiIHkyPSIxNi42NSIvPjwvc3ZnPg==","categories": ["search","database"- ]+ ],+ "engine": {+ "family": "Search",+ "protocol": "none",+ "default_port": 7700,+ "admin_user": null,+ "admin_password_var": "MASTER_KEY",+ "database_var": null,+ "port_var": "HTTP_PORT",+ "bind_var": "BIND_ADDRESS",+ "unit": "indexes",+ "client": "curl",+ "data_path": "/meili_data",+ "versions": [+ "1.12"+ ]+ }},{"id": "memos","name": "Memos","version": "1.0","description": "Lightweight, privacy-first note-taking and micro-blogging app.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBhdGggZD0iTTE1LjUgM0g1YTIgMiAwIDAgMC0yIDJ2MTRhMiAyIDAgMCAwIDIgMmgxNGEyIDIgMCAwIDAgMi0yVjguNXoiLz48cGF0aCBkPSJNMTUgM3Y2aDYiLz48L3N2Zz4=","categories": ["notes","productivity"@@ -924,6 +736,7 @@"name": "Metabase","version": "1.0","description": "Open-source business intelligence and dashboards tool for exploring your data.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PGxpbmUgeDE9IjEyIiB5MT0iMjAiIHgyPSIxMiIgeTI9IjEwIi8+PGxpbmUgeDE9IjE4IiB5MT0iMjAiIHgyPSIxOCIgeTI9IjQiLz48bGluZSB4MT0iNiIgeTE9IjIwIiB4Mj0iNiIgeTI9IjE2Ii8+PC9zdmc+","categories": ["analytics","business",@@ -935,27 +748,234 @@"name": "Miniflux","version": "1.0","description": "Minimalist and fast self-hosted RSS feed reader backed by PostgreSQL.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBhdGggZD0iTTQgMTFhOSA5IDAgMCAxIDkgOSIvPjxwYXRoIGQ9Ik00IDRhMTYgMTYgMCAwIDEgMTYgMTYiLz48Y2lyY2xlIGN4PSI1IiBjeT0iMTkiIHI9IjEiLz48L3N2Zz4=","categories": ["news","rss"]},+ {+ "id": "minio",+ "name": "MinIO",+ "version": "2024-01",+ "description": "High-performance, S3-compatible object storage for cloud-native applications",+ "icon": "https://serverkit.ai/imgs/template-icons/minio.png",+ "categories": [+ "storage",+ "s3",+ "cloud"+ ]+ },+ {+ "id": "mongo-express",+ "name": "Mongo Express",+ "version": "1.0",+ "description": "Web-based MongoDB admin interface for managing databases and collections",+ "icon": "https://serverkit.ai/imgs/template-icons/mongo-express.ico",+ "categories": [+ "database",+ "mongodb",+ "management"+ ]+ },+ {+ "id": "mongodb",+ "name": "MongoDB",+ "version": "7.0",+ "description": "Document store with flexible schemas, aggregation pipelines and change streams",+ "icon": "https://serverkit.ai/imgs/template-icons/mongodb.svg",+ "categories": [+ "database",+ "nosql"+ ],+ "engine": {+ "family": "Document",+ "protocol": "mongodb",+ "default_port": 27017,+ "admin_user": "root",+ "admin_password_var": "DB_PASSWORD",+ "database_var": "DB_NAME",+ "port_var": "PORT",+ "bind_var": "BIND_ADDRESS",+ "unit": "collections",+ "client": "mongosh",+ "data_path": "/data/db",+ "versions": [+ "7.0",+ "6.0"+ ]+ }+ },+ {+ "id": "mosquitto",+ "name": "Eclipse Mosquitto",+ "version": "2.0",+ "description": "Lightweight MQTT message broker for IoT and home automation",+ "icon": "https://serverkit.ai/imgs/template-icons/mosquitto.svg",+ "categories": [+ "home-automation",+ "iot",+ "messaging"+ ]+ },+ {+ "id": "mysql",+ "name": "MySQL",+ "version": "8.4",+ "description": "The most widely deployed open-source relational database, with InnoDB storage and mature replication",+ "icon": "https://serverkit.ai/imgs/template-icons/mysql.svg",+ "categories": [+ "database",+ "sql"+ ],+ "engine": {+ "family": "Relational",+ "protocol": "mysql",+ "default_port": 3308,+ "admin_user": "root",+ "admin_password_var": "DB_PASSWORD",+ "database_var": "DB_NAME",+ "port_var": "PORT",+ "bind_var": "BIND_ADDRESS",+ "unit": "tables",+ "client": "mysql",+ "data_path": "/var/lib/mysql",+ "versions": [+ "8.4",+ "8.0"+ ]+ }+ },+ {+ "id": "n8n",+ "name": "n8n",+ "version": "1.22",+ "description": "Extendable workflow automation tool for connecting apps and services",+ "icon": "https://serverkit.ai/imgs/template-icons/n8n.ico",+ "categories": [+ "productivity",+ "automation",+ "integration"+ ]+ },+ {+ "id": "navidrome",+ "name": "Navidrome",+ "version": "0.50",+ "description": "Modern music server and streamer compatible with Subsonic/Airsonic",+ "icon": "https://serverkit.ai/imgs/template-icons/navidrome.png",+ "categories": [+ "media",+ "music",+ "streaming"+ ]+ },+ {+ "id": "neo4j",+ "name": "Neo4j",+ "version": "5.20",+ "description": "Graph database with the Cypher query language for highly connected data",+ "icon": "https://serverkit.ai/imgs/template-icons/neo4j.svg",+ "categories": [+ "database",+ "graph"+ ],+ "engine": {+ "family": "Graph",+ "protocol": "none",+ "default_port": 7687,+ "admin_user": "neo4j",+ "admin_password_var": "DB_PASSWORD",+ "database_var": null,+ "port_var": "PORT",+ "bind_var": "BIND_ADDRESS",+ "unit": "nodes",+ "client": "cypher-shell",+ "data_path": "/data",+ "versions": [+ "5.20",+ "4.4"+ ]+ }+ },+ {+ "id": "netdata",+ "name": "Netdata",+ "version": "1.44",+ "description": "Real-time performance and health monitoring for systems and applications",+ "icon": "https://serverkit.ai/imgs/template-icons/netdata.ico",+ "categories": [+ "monitoring",+ "metrics",+ "realtime"+ ]+ },+ {+ "id": "nextcloud",+ "name": "Nextcloud",+ "version": "28.0",+ "description": "Self-hosted productivity platform with file sync and collaboration",+ "icon": "https://serverkit.ai/imgs/template-icons/nextcloud.svg",+ "categories": [+ "storage",+ "collaboration",+ "productivity"+ ]+ },+ {+ "id": "nginx-proxy-manager",+ "name": "Nginx Proxy Manager",+ "version": "2.10",+ "description": "Easy-to-use reverse proxy with SSL management",+ "icon": "https://serverkit.ai/imgs/template-icons/nginx-proxy-manager.png",+ "categories": [+ "networking",+ "proxy",+ "ssl"+ ]+ },+ {+ "id": "node-app",+ "name": "Node.js Application",+ "version": "20",+ "description": "Custom Node.js application. Supports Node 18-21. Perfect for Express, Next.js, or any Node.js project.",+ "icon": "https://serverkit.ai/imgs/template-icons/node-app.svg",+ "categories": [+ "development",+ "api",+ "custom"+ ]+ },{"id": "nodebb","name": "NodeBB","version": "1.0","description": "Modern, real-time forum and community platform built on Node.js.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBhdGggZD0iTTE3IDIxdi0yYTQgNCAwIDAgMC00LTRINWE0IDQgMCAwIDAtNCA0djIiLz48Y2lyY2xlIGN4PSI5IiBjeT0iNyIgcj0iNCIvPjxwYXRoIGQ9Ik0yMyAyMXYtMmE0IDQgMCAwIDAtMy0zLjg3TTE2IDMuMTNhNCA0IDAgMCAxIDAgNy43NSIvPjwvc3ZnPg==","categories": ["community","forum","business"]},+ {+ "id": "nodered",+ "name": "Node-RED",+ "version": "3.1",+ "description": "Flow-based programming tool for wiring together hardware devices and APIs",+ "icon": "https://serverkit.ai/imgs/template-icons/nodered.svg",+ "categories": [+ "home-automation",+ "automation",+ "iot"+ ]+ },{"id": "ntfy","name": "ntfy","version": "1.0","description": "Simple HTTP-based pub/sub service that pushes notifications to your phone or desktop via a POST.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBhdGggZD0iTTE4IDhBNiA2IDAgMCAwIDYgOGMwIDctMyA5LTMgOWgxOHMtMy0yLTMtOXoiLz48cGF0aCBkPSJNMTMuNzMgMjFhMiAyIDAgMCAxLTMuNDYgMCIvPjwvc3ZnPg==","categories": ["notifications","messaging"@@ -966,20 +986,94 @@"name": "Ollama + Open WebUI","version": "1.0","description": "Local LLM inference with Ollama and a friendly chat interface (Open WebUI).",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiPjxyZWN0IHg9IjMiIHk9IjMiIHdpZHRoPSIxOCIgaGVpZ2h0PSIxOCIgcng9IjIiLz48cGF0aCBkPSJNOCAxMmg4TTEyIDh2OCIvPjwvc3ZnPg==","categories": ["ai","llm","chat"]},+ {+ "id": "outline",+ "name": "Outline",+ "version": "0.74",+ "description": "Beautiful, real-time collaborative team wiki and knowledge base",+ "icon": "https://serverkit.ai/imgs/template-icons/outline.svg",+ "categories": [+ "productivity",+ "wiki",+ "collaboration"+ ]+ },{"id": "paperless-ngx","name": "Paperless-ngx","version": "1.0","description": "Document management system that scans, OCRs, indexes and archives your documents into a searchable online archive.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBhdGggZD0iTTE0IDJINmEyIDIgMCAwIDAtMiAydjE2YTIgMiAwIDAgMCAyIDJoMTJhMiAyIDAgMCAwIDItMlY4eiIvPjxwb2x5bGluZSBwb2ludHM9IjE0IDIgMTQgOCAyMCA4Ii8+PGxpbmUgeDE9IjE2IiB5MT0iMTMiIHgyPSI4IiB5Mj0iMTMiLz48bGluZSB4MT0iMTYiIHkxPSIxNyIgeDI9IjgiIHkyPSIxNyIvPjxwb2x5bGluZSBwb2ludHM9IjEwIDkgOSA5IDggOSIvPjwvc3ZnPg==",+ "categories": [+ "documents",+ "productivity"+ ]+ },+ {+ "id": "payload",+ "name": "Payload CMS",+ "version": "2.5",+ "description": "Modern TypeScript headless CMS with powerful admin panel and customization",+ "icon": "https://serverkit.ai/imgs/template-icons/payload.svg",+ "categories": [+ "cms",+ "headless",+ "typescript"+ ]+ },+ {+ "id": "pgadmin",+ "name": "pgAdmin 4",+ "version": "8.2",+ "description": "Web-based PostgreSQL administration and development platform",+ "icon": "https://serverkit.ai/imgs/template-icons/pgadmin.ico",+ "categories": [+ "database",+ "postgresql",+ "management"+ ]+ },+ {+ "id": "photoprism",+ "name": "PhotoPrism",+ "version": "231128",+ "description": "AI-powered photo management application with face recognition and auto-tagging",+ "icon": "https://serverkit.ai/imgs/template-icons/photoprism.svg",+ "categories": [+ "media",+ "photos",+ "ai"+ ]+ },+ {+ "id": "php-app",+ "name": "PHP Application",+ "version": "8.3",+ "description": "Custom PHP application with Apache. Supports PHP 8.0-8.3. Perfect for Laravel, WordPress themes, or any PHP project.",+ "icon": "https://serverkit.ai/imgs/template-icons/php-app.svg",+ "categories": [+ "development",+ "web",+ "custom"+ ]+ },+ {+ "id": "phpmyadmin",+ "name": "phpMyAdmin",+ "version": "5.2",+ "description": "Web-based MySQL and MariaDB administration tool",+ "icon": "https://serverkit.ai/imgs/template-icons/phpmyadmin.png","categories": [- "documents",- "productivity"+ "database",+ "mysql",+ "management"]},{@@ -987,6 +1081,7 @@"name": "Pi-hole","version": "1.0","description": "Network-wide ad-blocking DNS sinkhole with a web dashboard.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBvbHlnb24gcG9pbnRzPSIyMiAzIDIgMyAxMCAxMi40NiAxMCAxOSAxNCAyMSAxNCAxMi40NiAyMiAzIi8+PC9zdmc+","categories": ["networking","dns",@@ -998,26 +1093,106 @@"name": "Plane","version": "1.0","description": "Open-source project management and issue tracking with cycles, modules, and views (a Jira/Linear alternative).",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHJlY3QgeD0iMyIgeT0iMyIgd2lkdGg9IjE4IiBoZWlnaHQ9IjE4IiByeD0iMiIvPjxwYXRoIGQ9Ik04IDd2N00xMiA3djEwTTE2IDd2NCIvPjwvc3ZnPg==","categories": ["productivity","project-management"]},+ {+ "id": "plausible",+ "name": "Plausible Analytics",+ "version": "2.0",+ "description": "Privacy-friendly, lightweight alternative to Google Analytics",+ "icon": "https://serverkit.ai/imgs/template-icons/plausible.ico",+ "categories": [+ "analytics",+ "privacy",+ "monitoring"+ ]+ },+ {+ "id": "plex",+ "name": "Plex Media Server",+ "version": "1.32",+ "description": "Organize and stream your personal media collection to any device",+ "icon": "https://serverkit.ai/imgs/template-icons/plex.png",+ "categories": [+ "media",+ "streaming",+ "entertainment"+ ]+ },+ {+ "id": "portainer",+ "name": "Portainer",+ "version": "2.19",+ "description": "Lightweight Docker management UI with container visualization",+ "icon": "https://serverkit.ai/imgs/template-icons/portainer.png",+ "categories": [+ "devops",+ "docker",+ "management"+ ]+ },+ {+ "id": "postgresql",+ "name": "PostgreSQL",+ "version": "16",+ "description": "Standards-compliant relational database with JSONB, full-text search and a deep extension ecosystem",+ "icon": "https://serverkit.ai/imgs/template-icons/postgresql.svg",+ "categories": [+ "database",+ "sql"+ ],+ "engine": {+ "family": "Relational",+ "protocol": "postgresql",+ "default_port": 5433,+ "admin_user": "postgres",+ "admin_password_var": "DB_PASSWORD",+ "database_var": "DB_NAME",+ "port_var": "PORT",+ "bind_var": "BIND_ADDRESS",+ "unit": "tables",+ "client": "psql",+ "data_path": "/var/lib/postgresql/data",+ "versions": [+ "16",+ "15",+ "14"+ ]+ }+ },{"id": "posthog","name": "PostHog","version": "1.0","description": "Open-source product analytics with session replay, feature flags, A/B testing, and event autocapture.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PGxpbmUgeDE9IjEyIiB5MT0iMjAiIHgyPSIxMiIgeTI9IjEwIi8+PGxpbmUgeDE9IjE4IiB5MT0iMjAiIHgyPSIxOCIgeTI9IjQiLz48bGluZSB4MT0iNiIgeTE9IjIwIiB4Mj0iNiIgeTI9IjE2Ii8+PC9zdmc+","categories": ["analytics","business"]},+ {+ "id": "prometheus",+ "name": "Prometheus",+ "version": "2.48",+ "description": "Open-source monitoring and alerting toolkit designed for reliability and scalability",+ "icon": "https://serverkit.ai/imgs/template-icons/prometheus.svg",+ "categories": [+ "monitoring",+ "metrics",+ "alerting"+ ]+ },{"id": "prompture-hub","name": "Prompture Hub","version": "0.0.2","description": "Self-hosted LLM gateway. Hold real provider keys server-side, issue scoped hub keys, and meter every call. Drop-in OpenAI-compatible API.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiPjxwYXRoIGQ9Ik0xMiAyTDQuNSA2djEybDcuNSA0IDcuNS00VjZ6Ii8+PHBhdGggZD0iTTEyIDIybDcuNS00VjZNMTIgMnYxMCIvPjxjaXJjbGUgY3g9IjEyIiBjeT0iMTIiIHI9IjIiLz48L3N2Zz4=","categories": ["ai","llm",@@ -1030,16 +1205,30 @@"name": "Prowlarr","version": "1.0","description": "Indexer manager and proxy that integrates your indexers with the PVR apps",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PGNpcmNsZSBjeD0iMTEiIGN5PSIxMSIgcj0iOCIvPjxsaW5lIHgxPSIyMSIgeTE9IjIxIiB4Mj0iMTYuNjUiIHkyPSIxNi42NSIvPjwvc3ZnPg==","categories": ["media","automation"]},+ {+ "id": "python-app",+ "name": "Python Application",+ "version": "3.12",+ "description": "Custom Python application. Supports Python 3.9-3.12. Perfect for Flask, FastAPI, Django, or any Python project.",+ "icon": "https://serverkit.ai/imgs/template-icons/python-app.svg",+ "categories": [+ "development",+ "api",+ "custom"+ ]+ },{"id": "qbittorrent","name": "qBittorrent","version": "1.0","description": "Open-source BitTorrent client with a full-featured web UI",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBhdGggZD0iTTIxIDE1djRhMiAyIDAgMCAxLTIgMkg1YTIgMiAwIDAgMS0yLTJ2LTQiLz48cG9seWxpbmUgcG9pbnRzPSI3IDEwIDEyIDE1IDE3IDEwIi8+PGxpbmUgeDE9IjEyIiB5MT0iMTUiIHgyPSIxMiIgeTI9IjMiLz48L3N2Zz4=","categories": ["media","downloads"@@ -1050,6 +1239,7 @@"name": "Qdrant","version": "1.0","description": "Vector similarity search engine for AI/LLM and semantic-search applications.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiPjxjaXJjbGUgY3g9IjEyIiBjeT0iMTIiIHI9IjMiLz48cGF0aCBkPSJNMTIgMXYyMk0xIDloMjJNMSAxNWgyMiIvPjwvc3ZnPg==","categories": ["ai","database",@@ -1061,16 +1251,94 @@"name": "Radarr","version": "1.0","description": "PVR for movies that monitors, grabs, sorts, and renames films automatically",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHJlY3QgeD0iMiIgeT0iMiIgd2lkdGg9IjIwIiBoZWlnaHQ9IjIwIiByeD0iMi4xOCIvPjxsaW5lIHgxPSI3IiB5MT0iMiIgeDI9IjciIHkyPSIyMiIvPjxsaW5lIHgxPSIxNyIgeTE9IjIiIHgyPSIxNyIgeTI9IjIyIi8+PGxpbmUgeDE9IjIiIHkxPSIxMiIgeDI9IjIyIiB5Mj0iMTIiLz48bGluZSB4MT0iMiIgeTE9IjciIHgyPSI3IiB5Mj0iNyIvPjxsaW5lIHgxPSIyIiB5MT0iMTciIHgyPSI3IiB5Mj0iMTciLz48bGluZSB4MT0iMTciIHkxPSIxNyIgeDI9IjIyIiB5Mj0iMTciLz48bGluZSB4MT0iMTciIHkxPSI3IiB4Mj0iMjIiIHkyPSI3Ii8+PC9zdmc+","categories": ["media","automation"]},+ {+ "id": "redis-commander",+ "name": "Redis Commander",+ "version": "0.8",+ "description": "Web-based Redis management tool for viewing and editing data",+ "icon": "https://serverkit.ai/imgs/template-icons/redis-commander.ico",+ "categories": [+ "database",+ "redis",+ "management"+ ]+ },+ {+ "id": "redis",+ "name": "Redis",+ "version": "7.2",+ "description": "In-memory key-value store used for cache, queues and ephemeral state",+ "icon": "https://serverkit.ai/imgs/template-icons/redis.svg",+ "categories": [+ "database",+ "cache"+ ],+ "engine": {+ "family": "Key-value",+ "protocol": "redis",+ "default_port": 6379,+ "admin_user": "default",+ "admin_password_var": "DB_PASSWORD",+ "database_var": null,+ "port_var": "PORT",+ "bind_var": "BIND_ADDRESS",+ "unit": "keys",+ "client": "redis-cli",+ "data_path": "/data",+ "versions": [+ "7.2",+ "7.0"+ ]+ }+ },+ {+ "id": "registry",+ "name": "Docker Registry",+ "version": "2.8",+ "description": "Private Docker container image registry for storing and distributing container images",+ "icon": "https://serverkit.ai/imgs/template-icons/registry.png",+ "categories": [+ "devops",+ "docker",+ "registry"+ ]+ },+ {+ "id": "rocketchat",+ "name": "Rocket.Chat",+ "version": "6.5",+ "description": "Open-source team communication platform with chat, video, and file sharing",+ "icon": "https://serverkit.ai/imgs/template-icons/rocketchat.svg",+ "categories": [+ "collaboration",+ "chat",+ "communication"+ ]+ },+ {+ "id": "seafile",+ "name": "Seafile",+ "version": "11.0",+ "description": "Open-source file sync and share platform with built-in collaboration",+ "icon": "https://serverkit.ai/imgs/template-icons/seafile.png",+ "categories": [+ "storage",+ "sync",+ "collaboration"+ ]+ },{"id": "searxng","name": "SearXNG","version": "1.0","description": "Privacy-respecting metasearch engine that aggregates results from many sources without tracking you.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PGNpcmNsZSBjeD0iMTEiIGN5PSIxMSIgcj0iOCIvPjxsaW5lIHgxPSIyMSIgeTE9IjIxIiB4Mj0iMTYuNjUiIHkyPSIxNi42NSIvPjwvc3ZnPg==","categories": ["search","privacy"@@ -1081,17 +1349,31 @@"name": "SigNoz","version": "1.0","description": "OpenTelemetry-native observability platform for traces, metrics, and logs (an open-source APM alternative to Datadog).",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBvbHlsaW5lIHBvaW50cz0iMjIgMTIgMTggMTIgMTUgMjEgOSAzIDYgMTIgMiAxMiIvPjwvc3ZnPg==","categories": ["monitoring","observability","apm"]},+ {+ "id": "sonarqube",+ "name": "SonarQube",+ "version": "10.3",+ "description": "Continuous inspection of code quality and security vulnerabilities",+ "icon": "https://serverkit.ai/imgs/template-icons/sonarqube.ico",+ "categories": [+ "devops",+ "code-quality",+ "security"+ ]+ },{"id": "sonarr","name": "Sonarr","version": "1.0","description": "PVR for TV series that monitors, grabs, sorts, and renames episodes automatically",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHJlY3QgeD0iMiIgeT0iMiIgd2lkdGg9IjIwIiBoZWlnaHQ9IjIwIiByeD0iMi4xOCIvPjxsaW5lIHgxPSI3IiB5MT0iMiIgeDI9IjciIHkyPSIyMiIvPjxsaW5lIHgxPSIxNyIgeTE9IjIiIHgyPSIxNyIgeTI9IjIyIi8+PGxpbmUgeDE9IjIiIHkxPSIxMiIgeDI9IjIyIiB5Mj0iMTIiLz48bGluZSB4MT0iMiIgeTE9IjciIHgyPSI3IiB5Mj0iNyIvPjxsaW5lIHgxPSIyIiB5MT0iMTciIHgyPSI3IiB5Mj0iMTciLz48bGluZSB4MT0iMTciIHkxPSIxNyIgeDI9IjIyIiB5Mj0iMTciLz48bGluZSB4MT0iMTciIHkxPSI3IiB4Mj0iMjIiIHkyPSI3Ii8+PC9zdmc+","categories": ["media","automation"@@ -1102,27 +1384,141 @@"name": "Stirling PDF","version": "1.0","description": "Local web toolkit for splitting, merging, converting and OCR-ing PDF files.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBhdGggZD0iTTE0IDJINmEyIDIgMCAwIDAtMiAydjE2YTIgMiAwIDAgMCAyIDJoMTJhMiAyIDAgMCAwIDItMlY4eiIvPjxwb2x5bGluZSBwb2ludHM9IjE0IDIgMTQgOCAyMCA4Ii8+PGxpbmUgeDE9IjE2IiB5MT0iMTMiIHgyPSI4IiB5Mj0iMTMiLz48bGluZSB4MT0iMTYiIHkxPSIxNyIgeDI9IjgiIHkyPSIxNyIvPjxwb2x5bGluZSBwb2ludHM9IjEwIDkgOSA5IDggOSIvPjwvc3ZnPg==","categories": ["documents","productivity","pdf"]},+ {+ "id": "strapi",+ "name": "Strapi",+ "version": "4.15",+ "description": "Open-source headless CMS with customizable API and admin panel",+ "icon": "https://serverkit.ai/imgs/template-icons/strapi.svg",+ "categories": [+ "cms",+ "headless",+ "api"+ ]+ },+ {+ "id": "syncthing",+ "name": "Syncthing",+ "version": "1.27",+ "description": "Continuous file synchronization for decentralized, peer-to-peer sync",+ "icon": "https://serverkit.ai/imgs/template-icons/syncthing.svg",+ "categories": [+ "storage",+ "sync",+ "backup"+ ]+ },+ {+ "id": "traefik",+ "name": "Traefik",+ "version": "3.0",+ "description": "Modern HTTP reverse proxy and load balancer with automatic HTTPS",+ "icon": "https://serverkit.ai/imgs/template-icons/traefik.png",+ "categories": [+ "networking",+ "proxy",+ "ssl"+ ]+ },{"id": "typesense","name": "Typesense","version": "1.0","description": "Typo-tolerant search engine optimized for fast, instant search-as-you-type experiences.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PGNpcmNsZSBjeD0iMTEiIGN5PSIxMSIgcj0iOCIvPjxsaW5lIHgxPSIyMSIgeTE9IjIxIiB4Mj0iMTYuNjUiIHkyPSIxNi42NSIvPjwvc3ZnPg==","categories": ["search","database"]},+ {+ "id": "umami",+ "name": "Umami",+ "version": "2.9",+ "description": "Simple, fast, privacy-focused alternative to Google Analytics",+ "icon": "https://serverkit.ai/imgs/template-icons/umami.ico",+ "categories": [+ "analytics",+ "privacy",+ "monitoring"+ ]+ },+ {+ "id": "uptime-kuma",+ "name": "Uptime Kuma",+ "version": "1.23",+ "description": "A fancy self-hosted monitoring tool for websites and services",+ "icon": "https://serverkit.ai/imgs/template-icons/uptime-kuma.svg",+ "categories": [+ "monitoring",+ "devops"+ ]+ },+ {+ "id": "valkey",+ "name": "Valkey",+ "version": "8.0",+ "description": "Redis-compatible fork stewarded by the Linux Foundation -- a drop-in for cache workloads",+ "icon": "https://serverkit.ai/imgs/template-icons/valkey.svg",+ "categories": [+ "database",+ "cache"+ ],+ "engine": {+ "family": "Key-value",+ "protocol": "redis",+ "default_port": 6380,+ "admin_user": "default",+ "admin_password_var": "DB_PASSWORD",+ "database_var": null,+ "port_var": "PORT",+ "bind_var": "BIND_ADDRESS",+ "unit": "keys",+ "client": "valkey-cli",+ "data_path": "/data",+ "versions": [+ "8",+ "7.2"+ ]+ }+ },+ {+ "id": "vault",+ "name": "HashiCorp Vault",+ "version": "1.15",+ "description": "Secrets management and data protection platform for securing sensitive data",+ "icon": "https://serverkit.ai/imgs/template-icons/vault.svg",+ "categories": [+ "devops",+ "security",+ "secrets"+ ]+ },+ {+ "id": "vaultwarden",+ "name": "Vaultwarden",+ "version": "1.30",+ "description": "Lightweight Bitwarden-compatible password manager server",+ "icon": "https://serverkit.ai/imgs/template-icons/vaultwarden.svg",+ "categories": [+ "security",+ "passwords",+ "privacy"+ ]+ },{"id": "vikunja","name": "Vikunja","version": "1.0","description": "Self-hosted to-do list and task and project manager.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHBvbHlsaW5lIHBvaW50cz0iOSAxMSAxMiAxNCAyMiA0Ii8+PHBhdGggZD0iTTIxIDEydjdhMiAyIDAgMCAxLTIgMkg1YTIgMiAwIDAgMS0yLTJWNWEyIDIgMCAwIDEgMi0yaDExIi8+PC9zdmc+","categories": ["productivity","tasks"@@ -1133,6 +1529,7 @@"name": "WG-Easy","version": "1.0","description": "The easiest way to run WireGuard VPN with a web admin UI.",+ "icon": "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+PHJlY3QgeD0iMTYiIHk9IjE2IiB3aWR0aD0iNiIgaGVpZ2h0PSI2IiByeD0iMSIvPjxyZWN0IHg9IjIiIHk9IjE2IiB3aWR0aD0iNiIgaGVpZ2h0PSI2IiByeD0iMSIvPjxyZWN0IHg9IjkiIHk9IjIiIHdpZHRoPSI2IiBoZWlnaHQ9IjYiIHJ4PSIxIi8+PHBhdGggZD0iTTUgMTZ2LTNhMSAxIDAgMCAxIDEtMWgxMmExIDEgMCAwIDEgMSAxdjNNMTIgMTJWOCIvPjwvc3ZnPg==","categories": ["networking","vpn",@@ -1140,123 +1537,53 @@]},{- "id": "agentsite",- "name": "AgentSite",- "version": "1.0",- "description": "AI-powered website builder with multi-agent orchestration, deployed straight from its Git repository.",+ "id": "wikijs",+ "name": "Wiki.js",+ "version": "2.5",+ "description": "Modern and powerful wiki app built on Node.js",+ "icon": "https://serverkit.ai/imgs/template-icons/wikijs.svg","categories": [- "ai",+ "productivity",+ "wiki",+ "documentation"+ ]+ },+ {+ "id": "wordpress-external-db",+ "name": "WordPress (External Database)",+ "version": "6.4",+ "description": "WordPress CMS connecting to an existing external MySQL database. Use this for dev/prod setups sharing the same database with different table prefixes.",+ "icon": "https://serverkit.ai/imgs/template-icons/wordpress-external-db.png",+ "categories": [+ "cms",+ "blog","website",- "deployment"+ "development"+ ]+ },+ {+ "id": "wordpress",+ "name": "WordPress",+ "version": "6.4",+ "description": "World's most popular content management system for blogs and websites",+ "icon": "https://serverkit.ai/imgs/template-icons/wordpress.png",+ "categories": [+ "cms",+ "blog",+ "website"+ ]+ },+ {+ "id": "zigbee2mqtt",+ "name": "Zigbee2MQTT",+ "version": "1.35",+ "description": "Bridge Zigbee devices to MQTT without proprietary bridges or gateways",+ "icon": "https://serverkit.ai/imgs/template-icons/zigbee2mqtt.png",+ "categories": [+ "home-automation",+ "iot",+ "zigbee"]}- ],- "categories": [- "monitoring",- "devops",- "cms",- "blog",- "media",- "collaboration",- "storage",- "productivity",- "security",- "database",- "home-automation",- "development",- "networking",- "analytics",- "docker",- "git",- "proxy",- "ssl",- "iot",- "ci-cd",- "automation",- "custom",- "web",- "api",- "testing",- "ai",- "alerting",- "apm",- "audiobooks",- "authentication",- "backup",- "bookmarks",- "business",- "chat",- "cloud",- "code-quality",- "communication",- "community",- "conferencing",- "diagrams",- "dns",- "documentation",- "documents",- "downloads",- "ebooks",- "encryption",- "entertainment",- "federation",- "files",- "finance",- "firewall",- "flat-file",- "forum",- "gateway",- "gitlab",- "headless",- "ide",- "identity",- "integration",- "llm",- "logging",- "low-code",- "management",- "messaging",- "metrics",- "mongodb",- "music",- "mysql",- "news",- "notes",- "notifications",- "observability",- "passwords",- "pdf",- "photos",- "postgresql",- "privacy",- "project-management",- "prompture",- "publishing",- "rag",- "realtime",- "redis",- "registry",- "rss",- "s3",- "search",- "secrets",- "smart-home",- "sso",- "streaming",- "support",- "sync",- "tasks",- "threat-detection",- "tracing",- "typescript",- "video",- "visualization",- "vpn",- "website",- "whiteboard",- "wiki",- "workflow",- "zigbee",- "deployment"]-}+}\ No newline at end of filediff --git a/backend/templates/influxdb.yaml b/backend/templates/influxdb.yamlnew file mode 100644index 00000000..8754dd0f--- /dev/null+++ b/backend/templates/influxdb.yaml@@ -0,0 +1,100 @@+id: influxdb+name: InfluxDB+version: "2.7"+description: Purpose-built time-series database for metrics, sensors and monitoring data+icon: https://serverkit.ai/imgs/template-icons/influxdb.svg+categories:+ - database+ - timeseries+ - monitoring+website: https://www.influxdata.com+documentation: https://docs.influxdata.com/influxdb/v2/++engine:+ family: Time-series+ protocol: none+ default_port: 8086+ admin_user: admin+ admin_password_var: DB_PASSWORD+ database_var: DB_NAME+ port_var: PORT+ bind_var: BIND_ADDRESS+ unit: buckets+ client: influx+ data_path: /var/lib/influxdb2+ # 2.x only. 1.8 uses a completely different env contract+ # (INFLUXDB_ADMIN_USER / INFLUXDB_DB) and a different data path, so offering+ # it here would silently produce an unconfigured node.+ version_var: IMAGE_TAG+ versions:+ - "2.7"+ - "2.6"++variables:+ - name: IMAGE_TAG+ type: string+ default: "2.7"+ hidden: true+ description: Image tag; constrained to engine.versions by the installer+ - name: PORT+ type: port+ default: "8086"+ hidden: false+ description: Host port to publish InfluxDB on+ - name: BIND_ADDRESS+ type: string+ default: 127.0.0.1+ hidden: true+ description: Address the port binds to. 127.0.0.1 keeps the engine private.+ - name: DB_PASSWORD+ type: password+ # InfluxDB rejects setup passwords shorter than 8 characters.+ length: 28+ description: Password for the initial admin user+ - name: DB_NAME+ type: string+ default: default+ description: Initial bucket to create+ - name: INIT_ORG+ type: string+ default: serverkit+ description: Initial organization name+ - name: ADMIN_TOKEN+ type: random+ length: 48+ description: API token issued to the admin user++compose:+ services:+ app:+ image: influxdb:${IMAGE_TAG}-alpine+ container_name: ${APP_NAME}+ restart: unless-stopped+ ports:+ - "${BIND_ADDRESS}:${PORT}:8086"+ environment:+ # Setup mode refuses to start unless MODE, USERNAME, PASSWORD, ORG and+ # BUCKET are all present.+ DOCKER_INFLUXDB_INIT_MODE: setup+ DOCKER_INFLUXDB_INIT_USERNAME: admin+ DOCKER_INFLUXDB_INIT_PASSWORD: "${DB_PASSWORD}"+ DOCKER_INFLUXDB_INIT_ORG: "${INIT_ORG}"+ DOCKER_INFLUXDB_INIT_BUCKET: "${DB_NAME}"+ DOCKER_INFLUXDB_INIT_ADMIN_TOKEN: "${ADMIN_TOKEN}"+ volumes:+ # 2.x splits data and config; 1.x used a single /var/lib/influxdb.+ - influxdb-data:/var/lib/influxdb2+ - influxdb-config:/etc/influxdb2++ volumes:+ influxdb-data:+ influxdb-config:++ports:+ - port: "${PORT}"+ protocol: http+ description: HTTP API and UI++requirements:+ memory: 1GB+ storage: 10GBdiff --git a/backend/templates/mariadb.yaml b/backend/templates/mariadb.yamlnew file mode 100644index 00000000..47efae87--- /dev/null+++ b/backend/templates/mariadb.yaml@@ -0,0 +1,81 @@+id: mariadb+name: MariaDB+version: "11.4"+description: Community-developed MySQL fork -- a drop-in relational database with a faster release cadence+icon: https://serverkit.ai/imgs/template-icons/mariadb.svg+categories:+ - database+ - sql+website: https://mariadb.org+documentation: https://mariadb.com/kb/en/documentation/++engine:+ family: Relational+ protocol: mysql+ default_port: 3307+ admin_user: root+ admin_password_var: DB_PASSWORD+ database_var: DB_NAME+ port_var: PORT+ bind_var: BIND_ADDRESS+ unit: tables+ client: mariadb+ data_path: /var/lib/mysql+ version_var: IMAGE_TAG+ versions:+ - "11.4"+ - "10.11"++variables:+ - name: IMAGE_TAG+ type: string+ default: "11.4"+ hidden: true+ description: Image tag; constrained to engine.versions by the installer+ - name: PORT+ type: port+ # 3306 is usually the host MySQL/MariaDB.+ default: "3307"+ hidden: false+ description: Host port to publish MariaDB on+ - name: BIND_ADDRESS+ type: string+ default: 127.0.0.1+ hidden: true+ description: Address the port binds to. 127.0.0.1 keeps the engine private.+ - name: DB_PASSWORD+ type: password+ length: 28+ description: Password for the MariaDB root user+ - name: DB_NAME+ type: string+ default: app+ description: Initial database to create++compose:+ services:+ app:+ image: mariadb:${IMAGE_TAG}+ container_name: ${APP_NAME}+ restart: unless-stopped+ ports:+ - "${BIND_ADDRESS}:${PORT}:3306"+ environment:+ # MARIADB_* is the current contract. The MYSQL_* names still work for+ # backward compatibility but are legacy on this image.+ MARIADB_ROOT_PASSWORD: "${DB_PASSWORD}"+ MARIADB_DATABASE: "${DB_NAME}"+ volumes:+ - mariadb-data:/var/lib/mysql++ volumes:+ mariadb-data:++ports:+ - port: "${PORT}"+ protocol: mysql+ description: MySQL wire protocol++requirements:+ memory: 512MB+ storage: 5GBdiff --git a/backend/templates/meilisearch.yaml b/backend/templates/meilisearch.yamlindex f305d25d..6f3f6aa6 100644--- a/backend/templates/meilisearch.yaml+++ b/backend/templates/meilisearch.yaml@@ -9,11 +9,41 @@ categories:- search- database+# Marks this template as an installable database engine. Presence of this block+# is the ONLY thing that lists it in Databases -- adding it to an existing+# template is all it takes.+engine:+ family: Search+ # No SQL/Mongo/Redis client can introspect Meilisearch, so the database tree+ # offers no browsing for it rather than pretending otherwise.+ protocol: none+ default_port: 7700+ # Meilisearch has no user concept -- it authenticates with a master key.+ admin_password_var: MASTER_KEY+ port_var: HTTP_PORT+ bind_var: BIND_ADDRESS+ unit: indexes+ client: curl+ data_path: /meili_data+ version_var: IMAGE_TAG+ versions:+ - "1.12"+variables:+ - name: IMAGE_TAG+ type: string+ default: "1.12"+ hidden: true+ description: Image tag; constrained to engine.versions by the installer- name: HTTP_PORT- description: Port for the Meilisearch HTTP API (auto-assigned)+ description: Host port for the Meilisearch HTTP APItype: portdefault: "7700"+ hidden: false+ - name: BIND_ADDRESS+ description: Address the port binds to. 127.0.0.1 keeps the engine private.+ type: string+ default: 127.0.0.1hidden: true- name: MASTER_KEYdescription: Master key protecting the Meilisearch API (auto-generated)@@ -33,11 +63,14 @@ requirements:compose:services:meilisearch:- image: getmeili/meilisearch:v1.12+ # Note the leading "v" -- Meilisearch tags are v1.12, not 1.12.+ image: getmeili/meilisearch:v${IMAGE_TAG}container_name: ${APP_NAME}restart: unless-stoppedports:- - "${HTTP_PORT}:7700"+ # Private by default; the installer swaps BIND_ADDRESS to 0.0.0.0 only+ # on an explicit expose_public opt-in.+ - "${BIND_ADDRESS}:${HTTP_PORT}:7700"environment:MEILI_MASTER_KEY: "${MASTER_KEY}"MEILI_ENV: "production"diff --git a/backend/templates/mongodb.yaml b/backend/templates/mongodb.yamlnew file mode 100644index 00000000..5b0da369--- /dev/null+++ b/backend/templates/mongodb.yaml@@ -0,0 +1,81 @@+id: mongodb+name: MongoDB+version: "7.0"+description: Document store with flexible schemas, aggregation pipelines and change streams+icon: https://serverkit.ai/imgs/template-icons/mongodb.svg+categories:+ - database+ - nosql+website: https://www.mongodb.com+documentation: https://www.mongodb.com/docs/manual/++engine:+ family: Document+ protocol: mongodb+ default_port: 27017+ admin_user: root+ admin_password_var: DB_PASSWORD+ database_var: DB_NAME+ port_var: PORT+ bind_var: BIND_ADDRESS+ unit: collections+ client: mongosh+ data_path: /data/db+ version_var: IMAGE_TAG+ versions:+ - "7.0"+ - "6.0"++variables:+ - name: IMAGE_TAG+ type: string+ default: "7.0"+ hidden: true+ description: Image tag; constrained to engine.versions by the installer+ - name: PORT+ type: port+ default: "27017"+ hidden: false+ description: Host port to publish MongoDB on+ - name: BIND_ADDRESS+ type: string+ default: 127.0.0.1+ hidden: true+ description: Address the port binds to. 127.0.0.1 keeps the engine private.+ - name: DB_PASSWORD+ type: password+ length: 28+ description: Password for the MongoDB root user+ - name: DB_NAME+ type: string+ default: app+ description: Initial database to create++compose:+ services:+ app:+ image: mongo:${IMAGE_TAG}+ container_name: ${APP_NAME}+ restart: unless-stopped+ ports:+ - "${BIND_ADDRESS}:${PORT}:27017"+ environment:+ # BOTH of these must be present. With only one set, the entrypoint+ # starts mongod with authentication DISABLED.+ MONGO_INITDB_ROOT_USERNAME: root+ MONGO_INITDB_ROOT_PASSWORD: "${DB_PASSWORD}"+ MONGO_INITDB_DATABASE: "${DB_NAME}"+ volumes:+ - mongodb-data:/data/db++ volumes:+ mongodb-data:++ports:+ - port: "${PORT}"+ protocol: mongodb+ description: MongoDB wire protocol++requirements:+ memory: 1GB+ storage: 10GBdiff --git a/backend/templates/mysql.yaml b/backend/templates/mysql.yamlnew file mode 100644index 00000000..46c83512--- /dev/null+++ b/backend/templates/mysql.yaml@@ -0,0 +1,82 @@+id: mysql+name: MySQL+version: "8.4"+description: The most widely deployed open-source relational database, with InnoDB storage and mature replication+icon: https://serverkit.ai/imgs/template-icons/mysql.svg+categories:+ - database+ - sql+website: https://www.mysql.com+documentation: https://dev.mysql.com/doc/++engine:+ family: Relational+ protocol: mysql+ default_port: 3308+ admin_user: root+ admin_password_var: DB_PASSWORD+ database_var: DB_NAME+ port_var: PORT+ bind_var: BIND_ADDRESS+ unit: tables+ client: mysql+ data_path: /var/lib/mysql+ version_var: IMAGE_TAG+ versions:+ - "8.4"+ - "8.0"++variables:+ - name: IMAGE_TAG+ type: string+ default: "8.4"+ hidden: true+ description: Image tag; constrained to engine.versions by the installer+ - name: PORT+ type: port+ # 3306 is the host MySQL, 3307 the MariaDB template -- start above both.+ default: "3308"+ hidden: false+ description: Host port to publish MySQL on+ - name: BIND_ADDRESS+ type: string+ default: 127.0.0.1+ hidden: true+ description: Address the port binds to. 127.0.0.1 keeps the engine private.+ - name: DB_PASSWORD+ type: password+ length: 28+ description: Password for the MySQL root user+ - name: DB_NAME+ type: string+ default: app+ description: Initial database to create++compose:+ services:+ app:+ image: mysql:${IMAGE_TAG}+ container_name: ${APP_NAME}+ restart: unless-stopped+ ports:+ - "${BIND_ADDRESS}:${PORT}:3306"+ environment:+ # MYSQL_ROOT_PASSWORD is required; the alternatives+ # (MYSQL_ALLOW_EMPTY_PASSWORD / MYSQL_RANDOM_ROOT_PASSWORD) are exactly+ # what we do NOT want for a managed engine.+ MYSQL_ROOT_PASSWORD: "${DB_PASSWORD}"+ MYSQL_DATABASE: "${DB_NAME}"+ volumes:+ - mysql-data:/var/lib/mysql++ volumes:+ mysql-data:++ports:+ - port: "${PORT}"+ protocol: mysql+ description: MySQL wire protocol++requirements:+ memory: 512MB+ storage: 5GBdiff --git a/backend/templates/neo4j.yaml b/backend/templates/neo4j.yamlnew file mode 100644index 00000000..7e31d71d--- /dev/null+++ b/backend/templates/neo4j.yaml@@ -0,0 +1,86 @@+id: neo4j+name: Neo4j+version: "5.20"+description: Graph database with the Cypher query language for highly connected data+icon: https://serverkit.ai/imgs/template-icons/neo4j.svg+categories:+ - database+ - graph+website: https://neo4j.com+documentation: https://neo4j.com/docs/++engine:+ family: Graph+ protocol: none+ default_port: 7687+ admin_user: neo4j+ admin_password_var: DB_PASSWORD+ port_var: PORT+ bind_var: BIND_ADDRESS+ unit: nodes+ client: cypher-shell+ data_path: /data+ version_var: IMAGE_TAG+ versions:+ - "5.20"+ - "4.4"++variables:+ - name: IMAGE_TAG+ type: string+ default: "5.20"+ hidden: true+ description: Image tag; constrained to engine.versions by the installer+ - name: PORT+ type: port+ default: "7687"+ hidden: false+ description: Host port for the Bolt protocol+ - name: HTTP_PORT+ type: port+ default: "7474"+ hidden: false+ description: Host port for the Neo4j Browser+ - name: BIND_ADDRESS+ type: string+ default: 127.0.0.1+ hidden: true+ description: Address the ports bind to. 127.0.0.1 keeps the engine private.+ - name: DB_PASSWORD+ type: password+ # Neo4j 5 refuses to start with a password shorter than 8 characters.+ length: 28+ description: Password for the neo4j user++compose:+ services:+ app:+ image: neo4j:${IMAGE_TAG}+ container_name: ${APP_NAME}+ restart: unless-stopped+ ports:+ - "${BIND_ADDRESS}:${PORT}:7687"+ - "${BIND_ADDRESS}:${HTTP_PORT}:7474"+ environment:+ # One combined variable -- there is no NEO4J_PASSWORD. Setting+ # NEO4J_AUTH=none would disable authentication entirely.+ NEO4J_AUTH: "neo4j/${DB_PASSWORD}"+ volumes:+ - neo4j-data:/data+ - neo4j-logs:/logs++ volumes:+ neo4j-data:+ neo4j-logs:++ports:+ - port: "${PORT}"+ protocol: bolt+ description: Bolt protocol+ - port: "${HTTP_PORT}"+ protocol: http+ description: Neo4j Browser++requirements:+ memory: 2GB+ storage: 10GBdiff --git a/backend/templates/postgresql.yaml b/backend/templates/postgresql.yamlnew file mode 100644index 00000000..1246ef4b--- /dev/null+++ b/backend/templates/postgresql.yaml@@ -0,0 +1,86 @@+id: postgresql+name: PostgreSQL+version: "16"+description: Standards-compliant relational database with JSONB, full-text search and a deep extension ecosystem+icon: https://serverkit.ai/imgs/template-icons/postgresql.svg+categories:+ - database+ - sql+website: https://www.postgresql.org+documentation: https://www.postgresql.org/docs/++# Marks this template as an installable database engine. Presence of this block+# is the ONLY thing that lists it in Databases -- there is no engine allow-list+# in Python.+engine:+ family: Relational+ protocol: postgresql+ default_port: 5433+ admin_user: postgres+ admin_password_var: DB_PASSWORD+ database_var: DB_NAME+ port_var: PORT+ bind_var: BIND_ADDRESS+ unit: tables+ client: psql+ data_path: /var/lib/postgresql/data+ version_var: IMAGE_TAG+ versions:+ - "16"+ - "15"+ - "14"++variables:+ - name: IMAGE_TAG+ type: string+ default: "16"+ hidden: true+ description: Image tag; constrained to engine.versions by the installer+ - name: PORT+ type: port+ # 5432 is usually taken by a PostgreSQL on the host itself.+ default: "5433"+ hidden: false+ description: Host port to publish PostgreSQL on+ - name: BIND_ADDRESS+ type: string+ default: 127.0.0.1+ hidden: true+ description: Address the port binds to. 127.0.0.1 keeps the engine private.+ - name: DB_PASSWORD+ type: password+ length: 28+ description: Password for the postgres superuser+ - name: DB_NAME+ type: string+ default: postgres+ description: Initial database to create++compose:+ services:+ app:+ image: postgres:${IMAGE_TAG}-alpine+ container_name: ${APP_NAME}+ restart: unless-stopped+ ports:+ - "${BIND_ADDRESS}:${PORT}:5432"+ environment:+ # POSTGRES_PASSWORD is REQUIRED -- without it the entrypoint refuses to+ # initialise unless trust auth is explicitly opted into.+ POSTGRES_PASSWORD: "${DB_PASSWORD}"+ POSTGRES_USER: postgres+ POSTGRES_DB: "${DB_NAME}"+ volumes:+ - postgresql-data:/var/lib/postgresql/data++ volumes:+ postgresql-data:++ports:+ - port: "${PORT}"+ protocol: postgresql+ description: PostgreSQL wire protocol++requirements:+ memory: 512MB+ storage: 5GBdiff --git a/backend/templates/redis.yaml b/backend/templates/redis.yamlnew file mode 100644index 00000000..0d0aa46f--- /dev/null+++ b/backend/templates/redis.yaml@@ -0,0 +1,74 @@+id: redis+name: Redis+version: "7.2"+description: In-memory key-value store used for cache, queues and ephemeral state+icon: https://serverkit.ai/imgs/template-icons/redis.svg+categories:+ - database+ - cache+website: https://redis.io+documentation: https://redis.io/docs/++engine:+ family: Key-value+ protocol: redis+ default_port: 6379+ admin_user: default+ admin_password_var: DB_PASSWORD+ port_var: PORT+ bind_var: BIND_ADDRESS+ unit: keys+ client: redis-cli+ data_path: /data+ version_var: IMAGE_TAG+ versions:+ - "7.2"+ - "7.0"++variables:+ - name: IMAGE_TAG+ type: string+ default: "7.2"+ hidden: true+ description: Image tag; constrained to engine.versions by the installer+ - name: PORT+ type: port+ default: "6379"+ hidden: false+ description: Host port to publish Redis on+ - name: BIND_ADDRESS+ type: string+ default: 127.0.0.1+ hidden: true+ description: Address the port binds to. 127.0.0.1 keeps the engine private.+ - name: DB_PASSWORD+ type: password+ length: 28+ description: Password required by AUTH (requirepass)++compose:+ services:+ app:+ image: redis:${IMAGE_TAG}-alpine+ container_name: ${APP_NAME}+ restart: unless-stopped+ ports:+ - "${BIND_ADDRESS}:${PORT}:6379"+ # The official Redis image has NO password environment variable+ # (REDIS_PASSWORD is a Bitnami convention and is ignored here) --+ # authentication is configured on the server command line.+ command: redis-server --requirepass "${DB_PASSWORD}" --appendonly yes+ volumes:+ - redis-data:/data++ volumes:+ redis-data:++ports:+ - port: "${PORT}"+ protocol: redis+ description: RESP protocol++requirements:+ memory: 256MB+ storage: 1GBdiff --git a/backend/templates/valkey.yaml b/backend/templates/valkey.yamlnew file mode 100644index 00000000..f0e1e020--- /dev/null+++ b/backend/templates/valkey.yaml@@ -0,0 +1,73 @@+id: valkey+name: Valkey+version: "8.0"+description: Redis-compatible fork stewarded by the Linux Foundation -- a drop-in for cache workloads+icon: https://serverkit.ai/imgs/template-icons/valkey.svg+categories:+ - database+ - cache+website: https://valkey.io+documentation: https://valkey.io/docs/++engine:+ family: Key-value+ protocol: redis+ default_port: 6380+ admin_user: default+ admin_password_var: DB_PASSWORD+ port_var: PORT+ bind_var: BIND_ADDRESS+ unit: keys+ client: valkey-cli+ data_path: /data+ version_var: IMAGE_TAG+ versions:+ - "8"+ - "7.2"++variables:+ - name: IMAGE_TAG+ type: string+ default: "8"+ hidden: true+ description: Image tag; constrained to engine.versions by the installer+ - name: PORT+ type: port+ # Sits beside a Redis on 6379.+ default: "6380"+ hidden: false+ description: Host port to publish Valkey on+ - name: BIND_ADDRESS+ type: string+ default: 127.0.0.1+ hidden: true+ description: Address the port binds to. 127.0.0.1 keeps the engine private.+ - name: DB_PASSWORD+ type: password+ length: 28+ description: Password required by AUTH (requirepass)++compose:+ services:+ app:+ image: valkey/valkey:${IMAGE_TAG}-alpine+ container_name: ${APP_NAME}+ restart: unless-stopped+ ports:+ - "${BIND_ADDRESS}:${PORT}:6379"+ # Same as Redis: no password env var, auth goes on the command line.+ command: valkey-server --requirepass "${DB_PASSWORD}" --appendonly yes+ volumes:+ - valkey-data:/data++ volumes:+ valkey-data:++ports:+ - port: "${PORT}"+ protocol: redis+ description: RESP protocol++requirements:+ memory: 256MB+ storage: 1GBdiff --git a/backend/tests/test_database_engines.py b/backend/tests/test_database_engines.pynew file mode 100644index 00000000..0c7273c7--- /dev/null+++ b/backend/tests/test_database_engines.py@@ -0,0 +1,656 @@+"""Database engines = app templates carrying an ``engine:`` block.++The load-bearing test in this file is ``test_dropping_a_new_engine_yaml_lists_it``:+a brand-new engine becomes installable by adding a YAML file, with no Python+change anywhere. Everything else guards the safety rules around that.++Nothing here pulls an image or starts a container: installs stop at the+deployment-job row (``wait=False``), and the docker port probes are stubbed.+"""+import json+import os++import pytest+import yaml++from app import db+from app.models import Application, User+from app.services import database_engine_service as engines+from app.services.template_service import TemplateService++TEMPLATES_DIR = TemplateService.LOCAL_TEMPLATES_DIR++# A complete engine template, written to backend/templates/ by the fixture below.+NEW_ENGINE_YAML = """\+id: probedb+name: ProbeDB+version: "1.0"+description: A database that exists only for this test+categories:+ - database+engine:+ family: Document+ protocol: none+ default_port: 61234+ admin_user: root+ admin_password_var: DB_PASSWORD+ database_var: DB_NAME+ port_var: PORT+ bind_var: BIND_ADDRESS+ unit: collections+ client: probe-cli+ data_path: /probe/data+ version_var: IMAGE_TAG+ versions:+ - "1.0"+ - "0.9"+variables:+ - name: IMAGE_TAG+ type: string+ default: "1.0"+ hidden: true+ - name: PORT+ type: port+ default: "61234"+ hidden: false+ - name: BIND_ADDRESS+ type: string+ default: 127.0.0.1+ hidden: true+ - name: DB_PASSWORD+ type: password+ length: 28+ - name: DB_NAME+ type: string+ default: probe+compose:+ services:+ app:+ image: probe/probedb:${IMAGE_TAG}+ container_name: ${APP_NAME}+ restart: unless-stopped+ ports:+ - "${BIND_ADDRESS}:${PORT}:61234"+ environment:+ PROBE_PASSWORD: "${DB_PASSWORD}"+ PROBE_DB: "${DB_NAME}"+ volumes:+ - probedb-data:/probe/data+ volumes:+ probedb-data:+"""+++# ── fixtures ─────────────────────────────────────────────────────────────────[email protected](autouse=True)+def offline_templates(monkeypatch):+ """Keep the suite hermetic and fast.++ ``list_all_templates`` fans out to every configured remote repo, and the+ port helpers shell out to ``docker ps``. Neither belongs in a unit test.+ """+ monkeypatch.setattr(TemplateService, 'get_config',+ classmethod(lambda cls: {'repos': [], 'installed': {}}))+ monkeypatch.setattr(TemplateService, '_get_docker_used_ports',+ classmethod(lambda cls: set()))+ monkeypatch.setattr(TemplateService, '_managed_app_base_port',+ classmethod(lambda cls: 0))+ # No docker on the test host; never let a listing block on `docker inspect`.+ monkeypatch.setattr(engines, '_container_state', lambda app: None)+++def new_engine_yaml():+ """Drop a brand-new engine template into backend/templates/, then remove it.++ This is the whole design: no registration, no import, no code change.+ """+ path = os.path.join(TEMPLATES_DIR, 'probedb.yaml')+ with open(path, 'w', encoding='utf-8') as fh:+ fh.write(NEW_ENGINE_YAML)+ try:+ yield 'probedb'+ finally:+ if os.path.exists(path):+ os.remove(path)+++def viewer_headers(app):+ """A logged-in NON-admin, for the admin-only checks."""+ from flask_jwt_extended import create_access_token+ from werkzeug.security import generate_password_hash++ user = User(email='[email protected]', username='viewer',+ password_hash=generate_password_hash('x'),+ role=User.ROLE_DEVELOPER, is_active=True)+ db.session.add(user)+ db.session.commit()+ return {'Authorization': f'Bearer {create_access_token(identity=user.id)}'}+++def _install(client, headers, **body):+ return client.post('/api/v1/databases/engines', json=body, headers=headers)+++# ── the design proof ─────────────────────────────────────────────────────────+class TestZeroCodeChangeCatalog:++ def test_dropping_a_new_engine_yaml_lists_it(self, client, auth_headers, new_engine_yaml):+ """A new engine YAML appears in the catalog with NO code change."""+ response = client.get('/api/v1/databases/engines', headers=auth_headers)+ assert response.status_code == 200++ catalog = response.get_json()['catalog']+ entry = next((e for e in catalog if e['id'] == 'probedb'), None)+ assert entry is not None, 'a new engine template must appear with no code change'+ assert entry['name'] == 'ProbeDB'+ # Its engine metadata came through the loader intact.+ assert entry['engine']['family'] == 'Document'+ assert entry['engine']['unit'] == 'collections'+ assert entry['engine']['data_path'] == '/probe/data'+ assert entry['engine']['versions'] == ['1.0', '0.9']+ assert entry['installed_count'] == 0++ def test_new_engine_is_immediately_installable(self, client, auth_headers, new_engine_yaml):+ """...and installing it goes through the ordinary template pipeline."""+ response = _install(client, auth_headers, template_id='probedb',+ instance_name='probedb-one')+ assert response.status_code == 202, response.get_json()+ assert response.get_json()['job_id']++ def test_engine_removed_when_yaml_is_removed(self, client, auth_headers):+ """The catalog is derived, not cached: no YAML, no entry."""+ response = client.get('/api/v1/databases/engines', headers=auth_headers)+ ids = [e['id'] for e in response.get_json()['catalog']]+ assert 'probedb' not in ids++ def test_non_engine_templates_are_excluded(self, client, auth_headers):+ """106 templates ship; only the ones declaring `engine:` are listed."""+ response = client.get('/api/v1/databases/engines', headers=auth_headers)+ catalog = response.get_json()['catalog']+ ids = {e['id'] for e in catalog}+ assert 'gitea' not in ids # an app, not an engine+ assert 'redis-commander' not in ids # an admin UI, not an engine+ assert 'postgresql' in ids+ assert 'cockroachdb' in ids+ assert all(isinstance(e.get('engine'), dict) for e in catalog)+++# ── catalog shape ────────────────────────────────────────────────────────────+class TestCatalog:++ def test_requires_auth(self, client):+ assert client.get('/api/v1/databases/engines').status_code == 401++ def test_ships_the_expected_engines(self, client, auth_headers):+ response = client.get('/api/v1/databases/engines', headers=auth_headers)+ assert response.status_code == 200+ ids = {e['id'] for e in response.get_json()['catalog']}+ expected = {'postgresql', 'mysql', 'mariadb', 'mongodb', 'redis', 'valkey',+ 'cockroachdb', 'clickhouse', 'influxdb', 'neo4j',+ 'meilisearch', 'couchdb'}+ assert expected <= ids++ def test_families_are_derived_from_the_response(self, client, auth_headers):+ """The UI must not need its own family list."""+ data = client.get('/api/v1/databases/engines', headers=auth_headers).get_json()+ families = set(data['families'])+ assert {'Relational', 'Document', 'Key-value', 'Search'} <= families+ # Only families actually present are offered as filters.+ present = {(e['engine'] or {}).get('family') for e in data['catalog']}+ assert families <= present++ def test_installed_is_empty_without_apps(self, client, auth_headers):+ data = client.get('/api/v1/databases/engines', headers=auth_headers).get_json()+ assert data['installed'] == []++ def test_catalog_does_not_leak_server_paths(self, client, auth_headers):+ data = client.get('/api/v1/databases/engines', headers=auth_headers).get_json()+ assert all('filepath' not in e for e in data['catalog'])+++# ── loader / validator (the `engine:` block plumbing) ────────────────────────+class TestEngineBlockPlumbing:++ def test_loader_carries_engine_through_the_listing(self, app, new_engine_yaml):+ """`list_local_templates` used to project a fixed field set and drop it."""+ entry = next(t for t in TemplateService.list_local_templates()+ if t['id'] == 'probedb')+ assert entry['engine']['protocol'] == 'none'++ def test_repo_index_carries_engine(self, app, new_engine_yaml):+ """A panel syncing this repo can list engines without fetching each YAML."""+ index = TemplateService.build_repo_index()+ entry = next(t for t in index['templates'] if t['id'] == 'probedb')+ assert entry['engine']['family'] == 'Document'++ def test_validator_accepts_a_template_without_an_engine_block(self, app):+ result = TemplateService.get_template('gitea')+ assert result['success']+ assert TemplateService.engine_metadata(result['template']) is None+ assert TemplateService.validate_template(result['template'])['valid']++ def test_validator_rejects_a_malformed_engine_block(self, app):+ bad = {'name': 'x', 'version': '1', 'description': 'd',+ 'compose': {'services': {}},+ 'engine': {'family': 'Nonsense', 'protocol': 'telepathy',+ 'default_port': 99999}}+ result = TemplateService.validate_template(bad)+ assert not result['valid']+ joined = ' '.join(result['errors'])+ assert 'engine.family' in joined+ assert 'engine.protocol' in joined+ assert 'engine.default_port' in joined++ def test_validator_rejects_a_non_mapping_engine_block(self, app):+ bad = {'name': 'x', 'version': '1', 'description': 'd',+ 'compose': {'services': {}}, 'engine': 'yes please'}+ assert not TemplateService.validate_template(bad)['valid']++ def test_catalog_entry_warns_about_variables_that_do_not_exist(self, app):+ entry = {'id': 'x', 'name': 'x', 'version': '1', 'description': 'd',+ 'compose': {'services': {}},+ 'variables': [{'name': 'PORT', 'type': 'port'}],+ 'engine': {'family': 'Relational', 'admin_password_var': 'NOPE'}}+ result = TemplateService.validate_catalog_entry(entry)+ assert result['valid'] # a warning, not a hard failure+ assert any('NOPE' in w for w in result['warnings'])++ def test_catalog_schema_documents_the_engine_block(self, client, auth_headers):+ schema = client.get('/api/v1/templates/catalog/schema',+ headers=auth_headers).get_json()+ assert schema['engine_block']['optional'] is True+ assert 'Relational' in schema['engine_block']['families']+ assert 'none' in schema['engine_block']['protocols']+ fields = {f['field'] for f in schema['engine_block']['fields']}+ assert {'family', 'protocol', 'admin_password_var', 'data_path'} <= fields++ def test_shipped_engine_templates_all_validate(self, app):+ """Every engine we ship parses, validates and declares what it promises."""+ for entry in TemplateService.list_local_templates():+ if not entry.get('engine'):+ continue+ fetched = TemplateService.get_template(entry['id'])+ assert fetched['success'], entry['id']+ template = fetched['template']+ assert TemplateService.validate_template(template)['valid'], entry['id']+ result = TemplateService.validate_catalog_entry(template)+ assert result['valid'], (entry['id'], result['errors'])+ assert not result['warnings'], (entry['id'], result['warnings'])+++class TestShippedEngineTemplateSafety:+ """Safety rules 1 and 5 are properties of the template files themselves."""++ @staticmethod+ def _engine_templates():+ out = []+ for entry in TemplateService.list_local_templates():+ if entry.get('engine'):+ out.append((entry['id'], TemplateService.get_template(entry['id'])['template']))+ return out++ def test_every_published_port_binds_to_loopback(self, app):+ for template_id, template in self._engine_templates():+ for service in template['compose']['services'].values():+ for mapping in service.get('ports', []) or []:+ assert str(mapping).startswith('${BIND_ADDRESS}:'), \+ f'{template_id} publishes {mapping} without the private bind'++ def test_bind_address_defaults_to_loopback(self, app):+ for template_id, template in self._engine_templates():+ names = {v['name']: v for v in template['variables']}+ assert names['BIND_ADDRESS']['default'] == '127.0.0.1', template_id++ def test_every_engine_declares_a_named_data_volume(self, app):+ for template_id, template in self._engine_templates():+ assert template['compose'].get('volumes'), \+ f'{template_id} has no named volume; its data would not survive'++ def test_every_engine_restarts_unless_stopped(self, app):+ for template_id, template in self._engine_templates():+ for service in template['compose']['services'].values():+ assert service.get('restart') == 'unless-stopped', template_id++ def test_admin_secret_is_a_generated_variable(self, app):+ """The secret goes through the existing password path, not a literal."""+ for template_id, template in self._engine_templates():+ engine = TemplateService.engine_metadata(template)+ secret_var = engine.get('admin_password_var')+ if not secret_var:+ # CockroachDB single-node runs --insecure; it declares no secret.+ assert template_id == 'cockroachdb', template_id+ continue+ declared = {v['name']: v for v in template['variables']}+ assert declared[secret_var]['type'] in ('password', 'random'), template_id+++# ── install: validation + safety rules ───────────────────────────────────────+class TestInstallValidation:++ def test_unknown_template_is_404(self, client, auth_headers):+ response = _install(client, auth_headers, template_id='not-a-real-engine')+ assert response.status_code == 404+ assert 'error' in response.get_json()++ def test_template_id_is_required(self, client, auth_headers):+ response = _install(client, auth_headers)+ assert response.status_code == 400++ def test_non_engine_template_is_rejected(self, client, auth_headers):+ """Only templates declaring `engine:` install through this route."""+ response = _install(client, auth_headers, template_id='gitea',+ instance_name='gitea-here')+ assert response.status_code == 400+ assert 'engine' in response.get_json()['error']++ def test_version_outside_the_template_allowlist_is_rejected(self, client, auth_headers):+ """Safety rule 6: the image tag can never be caller-chosen."""+ response = _install(client, auth_headers, template_id='postgresql',+ instance_name='pg-evil', version='../../evil:latest')+ assert response.status_code == 400+ body = response.get_json()+ assert 'not offered' in body['error']+ assert body['versions'] == ['16', '15', '14']++ def test_declared_version_becomes_the_image_tag(self, app, new_engine_yaml):+ plan = engines.plan_install(template_id='probedb', version='0.9')+ assert plan['variables']['IMAGE_TAG'] == '0.9'++ def test_initial_database_is_rejected_when_unsupported(self, client, auth_headers):+ """Redis has no database_var; say so instead of silently dropping it."""+ response = _install(client, auth_headers, template_id='redis',+ instance_name='redis-one', initial_database='shop')+ assert response.status_code == 400+ assert 'initial database' in response.get_json()['error']+++class TestPortCollision:++ def test_busy_port_is_refused_with_a_suggestion(self, app, monkeypatch):+ """Safety rule 3: refuse, and name a port that would work."""+ monkeypatch.setattr(TemplateService, '_port_is_free',+ classmethod(lambda cls, port: False))+ monkeypatch.setattr(TemplateService, '_find_available_port',+ classmethod(lambda cls, start=8000, max_attempts=1000: 5599))+ result = engines.plan_install(template_id='postgresql', port=5433)+ assert result['status_code'] == 409+ assert result['port'] == 5433+ assert result['suggested_port'] == 5599++ def test_collision_surfaces_as_409_over_http(self, client, auth_headers, monkeypatch):+ monkeypatch.setattr(TemplateService, '_port_is_free',+ classmethod(lambda cls, port: False))+ response = _install(client, auth_headers, template_id='postgresql',+ instance_name='pg-clash', port=5433)+ assert response.status_code == 409+ assert 'already in use' in response.get_json()['error']++ def test_free_port_is_honored_not_reassigned(self, app, monkeypatch):+ """The documented `port` parameter has to be real, not advisory."""+ monkeypatch.setattr(TemplateService, '_port_is_free',+ classmethod(lambda cls, port: True))+ plan = engines.plan_install(template_id='postgresql', port=15432)+ assert plan['variables']['PORT'] == '15432'+ prepared = TemplateService._prepare_install_variables(+ 'postgresql', TemplateService.get_template('postgresql')['template'],+ 'pg-fixed', plan['variables'])+ assert prepared['variables']['PORT'] == '15432'++ def test_out_of_range_port_is_rejected(self, app):+ assert engines.plan_install(+ template_id='postgresql', port=99999)['status_code'] == 400+++class TestPrivateByDefault:++ def test_bind_is_loopback_without_expose_public(self, app):+ plan = engines.plan_install(template_id='postgresql')+ assert plan['variables']['BIND_ADDRESS'] == '127.0.0.1'+ assert plan.get('warning') is None++ def test_expose_public_binds_all_interfaces_and_warns(self, app):+ plan = engines.plan_install(template_id='postgresql', expose_public=True)+ assert plan['variables']['BIND_ADDRESS'] == '0.0.0.0'+ assert 'any network interface' in plan['warning']++ def test_caller_variables_cannot_override_the_private_bind(self, app):+ """The explicit flag wins over a handcrafted variables payload."""+ plan = engines.plan_install(template_id='postgresql',+ variables={'BIND_ADDRESS': '0.0.0.0'})+ assert plan['variables']['BIND_ADDRESS'] == '127.0.0.1'++ def test_warning_reaches_the_http_response(self, client, auth_headers):+ response = _install(client, auth_headers, template_id='postgresql',+ instance_name='pg-public', expose_public=True)+ assert response.status_code == 202+ assert 'warning' in response.get_json()++ def test_passwordless_engine_cannot_be_exposed_publicly(self, app):+ """CockroachDB single-node runs `--insecure` — there is no auth to+ expose. For engines like it the loopback bind is the only control, so+ publishing one to every interface must be refused, not warned about."""+ plan = engines.plan_install(template_id='cockroachdb', expose_public=True)+ assert plan.get('error'), 'exposing an unauthenticated engine must fail'+ assert plan['status_code'] == 400+ assert 'without authentication' in plan['error']++ def test_passwordless_engine_still_installs_privately(self, app):+ plan = engines.plan_install(template_id='cockroachdb')+ assert not plan.get('error')+ assert plan['variables']['BIND_ADDRESS'] == '127.0.0.1'++ def test_shipped_passwordless_engines_are_known(self, app):+ """If a future template drops its admin_password_var, this test is the+ thing that makes the consequence visible instead of silent."""+ passwordless = sorted(+ e['id'] for e in engines.engine_catalog()+ if not (e.get('engine') or {}).get('admin_password_var')+ )+ assert passwordless == ['cockroachdb'], (+ f'unexpected engines without admin credentials: {passwordless}'+ )+++class TestAdminOnly:+ """Safety rule 2 — every mutating route is admin-only."""++ def test_install_rejects_a_non_admin(self, client, viewer_headers):+ response = _install(client, viewer_headers, template_id='postgresql',+ instance_name='pg-nope')+ assert response.status_code == 403+ assert Application.query.count() == 0++ def test_install_rejects_anonymous(self, client):+ assert _install(client, {}, template_id='postgresql').status_code == 401++ def test_reading_the_catalog_does_not_require_admin(self, client, viewer_headers):+ assert client.get('/api/v1/databases/engines',+ headers=viewer_headers).status_code == 200+++# ── install: happy path ──────────────────────────────────────────────────────+class TestInstallHappyPath:++ def test_install_returns_a_deployment_job(self, client, auth_headers):+ """Delegates to the template pipeline so the UI opens the deploy console."""+ response = _install(client, auth_headers, template_id='postgresql',+ instance_name='pg-main')+ assert response.status_code == 202, response.get_json()+ body = response.get_json()+ assert body['success'] is True+ assert body['job_id']+ assert body['job']['kind'] == 'template_install'+ assert body['app_name'] == 'pg-main'+ assert body['engine']['protocol'] == 'postgresql'++ def test_install_plan_renders_the_engine_compose(self, app):+ from app.services.deployment_job_service import DeploymentJobService++ plan = engines.plan_install(template_id='mongodb', instance_name='mongo-main',+ initial_database='shop')+ built = TemplateService.build_install_plan(+ 'mongodb', plan['app_name'], plan['variables'])+ assert built['success']+ compose = next(step for step in built['plan']['steps']+ if step.get('path', '').endswith('docker-compose.yml'))['content']+ rendered = yaml.safe_load(compose)+ service = rendered['services']['app']+ assert service['image'] == 'mongo:7.0'+ assert service['environment']['MONGO_INITDB_ROOT_USERNAME'] == 'root'+ assert service['environment']['MONGO_INITDB_DATABASE'] == 'shop'+ assert service['ports'][0].startswith('127.0.0.1:')+ assert 'mongodb-data' in rendered['volumes']+ assert DeploymentJobService # imported to prove the pipeline is the same one++ def test_instance_name_defaults_and_does_not_collide(self, app):+ db.session.add(Application(name='postgresql', app_type='docker',+ user_id=1, root_path='/tmp/postgresql'))+ db.session.commit()+ plan = engines.plan_install(template_id='postgresql')+ assert plan['app_name'] == 'postgresql-2'++ def test_generated_password_is_not_a_template_literal(self, app):+ """Safety rule 4: the secret comes from the existing password path."""+ template = TemplateService.get_template('postgresql')['template']+ prepared = TemplateService._prepare_install_variables(+ 'postgresql', template, 'pg-secret', {})+ password = prepared['variables']['DB_PASSWORD']+ assert len(password) == 28+ assert password not in json.dumps(template)++ def test_password_shown_in_the_drawer_is_the_one_installed(self, app):+ """The install drawer generates/reveals the secret and sends it as a+ `variables` entry; the pipeline must use exactly that value, or the+ password the operator copied would not be the one that works."""+ template = TemplateService.get_template('postgresql')['template']+ prepared = TemplateService._prepare_install_variables(+ 'postgresql', template, 'pg-chosen', {'DB_PASSWORD': 'chosen-by-the-drawer'})+ assert prepared['variables']['DB_PASSWORD'] == 'chosen-by-the-drawer'++ def test_install_response_does_not_echo_the_secret(self, client, auth_headers):+ """Surfaced once, at the moment of choosing it -- never read back."""+ secret = 'do-not-echo-this-secret'+ response = _install(client, auth_headers, template_id='postgresql',+ instance_name='pg-quiet',+ variables={'DB_PASSWORD': secret})+ assert response.status_code == 202+ assert secret not in response.get_data(as_text=True)+++# ── installed instances ──────────────────────────────────────────────────────+def _make_installed_engine(tmp_path, monkeypatch, *, template_id='postgresql',+ name='pg-main', bind='127.0.0.1'):+ """An Application that looks exactly like a finished engine install."""+ root = tmp_path / name+ root.mkdir()+ (root / '.serverkit-template.json').write_text(json.dumps({+ 'template_id': template_id,+ 'template_version': '16',+ 'variables': {'PORT': '5433', 'BIND_ADDRESS': bind,+ 'DB_NAME': 'shop', 'DB_PASSWORD': 'sup3rs3cret-do-not-leak'},+ }), encoding='utf-8')++ application = Application(name=name, app_type='docker', status='running',+ user_id=1, port=5433, root_path=str(root))+ db.session.add(application)+ db.session.commit()+ monkeypatch.setattr(TemplateService, 'get_config', classmethod(+ lambda cls: {'repos': [], 'installed': {+ str(application.id): {'template_id': template_id}}}))+ return application+++class TestInstalledEngines:++ def test_installed_engine_is_listed_with_its_metadata(self, client, auth_headers,+ tmp_path, monkeypatch):+ application = _make_installed_engine(tmp_path, monkeypatch)+ data = client.get('/api/v1/databases/engines', headers=auth_headers).get_json()+ assert len(data['installed']) == 1+ instance = data['installed'][0]+ assert instance['app_id'] == application.id+ assert instance['template_id'] == 'postgresql'+ assert instance['engine']['protocol'] == 'postgresql'+ assert instance['port'] == 5433+ assert instance['exposed_public'] is False++ def test_catalog_counts_the_instance(self, client, auth_headers, tmp_path, monkeypatch):+ application = _make_installed_engine(tmp_path, monkeypatch)+ data = client.get('/api/v1/databases/engines', headers=auth_headers).get_json()+ entry = next(e for e in data['catalog'] if e['id'] == 'postgresql')+ assert entry['installed_count'] == 1+ assert entry['instances'] == [application.id]++ def test_public_bind_is_reported(self, client, auth_headers, tmp_path, monkeypatch):+ _make_installed_engine(tmp_path, monkeypatch, bind='0.0.0.0')+ data = client.get('/api/v1/databases/engines', headers=auth_headers).get_json()+ assert data['installed'][0]['exposed_public'] is True++ def test_secret_is_never_serialized(self, client, auth_headers, tmp_path, monkeypatch):+ """Safety rule 4: the password crosses once, at install, and never again."""+ _make_installed_engine(tmp_path, monkeypatch)+ response = client.get('/api/v1/databases/engines', headers=auth_headers)+ assert 'sup3rs3cret-do-not-leak' not in response.get_data(as_text=True)+ instance = response.get_json()['installed'][0]+ assert instance['has_secret'] is True+ assert 'DB_PASSWORD' not in instance['variables']++ def test_non_engine_apps_are_not_listed_as_engines(self, client, auth_headers,+ tmp_path, monkeypatch):+ _make_installed_engine(tmp_path, monkeypatch, template_id='gitea', name='git')+ data = client.get('/api/v1/databases/engines', headers=auth_headers).get_json()+ assert data['installed'] == []++ def test_is_engine_app_reads_the_app_directory_when_config_is_lost(+ self, app, tmp_path, monkeypatch):+ """A reset templates.json must not orphan an installed engine."""+ application = _make_installed_engine(tmp_path, monkeypatch)+ monkeypatch.setattr(TemplateService, 'get_config',+ classmethod(lambda cls: {'repos': [], 'installed': {}}))+ assert engines.app_template_id(application) == 'postgresql'+ assert engines.is_engine_app(application) is True+++# ── uninstall: the data volume ───────────────────────────────────────────────+class TestUninstallPreservesData:+ """Safety rule 5, enforced on the shared app-delete route."""++ @pytest.fixture+ def compose_down_calls(self, monkeypatch):+ from app.services.docker_service import DockerService+ calls = []++ def fake_down(project_path, volumes=False, remove_orphans=True, compose_file=None):+ calls.append({'volumes': volumes})+ return {'success': True}++ monkeypatch.setattr(DockerService, 'compose_down', classmethod(+ lambda cls, *a, **kw: fake_down(*a, **kw)))+ return calls++ def test_engine_delete_keeps_the_volume_by_default(self, client, auth_headers,+ tmp_path, monkeypatch,+ compose_down_calls):+ application = _make_installed_engine(tmp_path, monkeypatch)+ response = client.delete(f'/api/v1/apps/{application.id}', headers=auth_headers)+ assert response.status_code == 200+ assert compose_down_calls == [{'volumes': False}]++ def test_remove_data_true_removes_the_volume(self, client, auth_headers,+ tmp_path, monkeypatch,+ compose_down_calls):+ application = _make_installed_engine(tmp_path, monkeypatch)+ response = client.delete(f'/api/v1/apps/{application.id}?remove_data=true',+ headers=auth_headers)+ assert response.status_code == 200+ assert compose_down_calls == [{'volumes': True}]++ def test_ordinary_apps_keep_the_historic_behavior(self, client, auth_headers,+ tmp_path, monkeypatch,+ compose_down_calls):+ application = _make_installed_engine(tmp_path, monkeypatch,+ template_id='gitea', name='git')+ client.delete(f'/api/v1/apps/{application.id}', headers=auth_headers)+ assert compose_down_calls == [{'volumes': True}]diff --git a/backend/tests/test_template_catalog_validation.py b/backend/tests/test_template_catalog_validation.pyindex d7e4f0ca..e93ca085 100644--- a/backend/tests/test_template_catalog_validation.py+++ b/backend/tests/test_template_catalog_validation.py@@ -243,6 +243,49 @@ def test_index_entry_fields_match_template_source():)+def test_index_carries_the_engine_block_for_engine_templates():+ """A database engine is a template with an ``engine:`` block, and the index+ is what a panel syncing this bundle as a repo reads.++ If the block is missing from the index, a synced CockroachDB arrives as an+ ordinary app template and never appears in the Databases engine catalog --+ silently, because everything still installs. This has drifted once already:+ the index was regenerated by a path that dropped the block.+ """+ with open(INDEX_PATH, encoding="utf-8") as fh:+ index = json.load(fh)+ by_id = {e["id"]: e for e in index["templates"] if e.get("id")}++ failures = []+ for filename in _template_files():+ template = _load_raw(filename)+ tid = template.get("id")+ source_engine = template.get("engine")+ if not isinstance(source_engine, dict):+ continue+ entry = by_id.get(tid)+ if entry is None:+ continue # absence is already reported by the sync test+ if not isinstance(entry.get("engine"), dict):+ failures.append(f"{tid}: declares engine: but index.json omits it")+ continue+ # The index carries the NORMALIZED block (the loader fills in defaults+ # like bind_var), so compare against what the service computes rather+ # than the raw YAML.+ expected = TemplateService.engine_metadata(template)+ if entry["engine"] != expected:+ differing = sorted(+ k for k in set(expected) | set(entry["engine"])+ if expected.get(k) != entry["engine"].get(k)+ )+ failures.append(f"{tid}: index engine block differs on {differing}")++ assert not failures, (+ "index.json engine blocks drifted -- regenerate with "+ "TemplateService.export_repo_index():\n" + "\n".join(failures)+ )++def test_build_repo_index_covers_disk():"""``build_repo_index()`` (the publishable generated index consumed by therepo-sync flow) must enumerate every template currently on disk."""diff --git a/frontend/src/components/databases/DbBlankStates.jsx b/frontend/src/components/databases/DbBlankStates.jsxnew file mode 100644index 00000000..4cfb5abc--- /dev/null+++ b/frontend/src/components/databases/DbBlankStates.jsx@@ -0,0 +1,150 @@+import { Link } from 'react-router-dom';+import {+ Loader2, Plus, Terminal, Table2, Activity, RefreshCw, ShieldAlert, Layers,+} from 'lucide-react';+import { Button } from '@/components/ui/button';+import EngineGlyph from './EngineGlyph';+import { engineLocation, engineMeta, engineTreeStatus, engineUnit, singular } from './engineHelpers';++// The three states the workspace can be in when there is nothing to show yet.+// Each one names what is happening and offers the single next step, rather than+// leaving an empty pane and a shrug.++// An engine template whose deploy is still running.+export function EngineInstallingPanel({ instance, onRefresh }) {+ const failed = engineTreeStatus(instance) === 'failed';+ const meta = engineMeta(instance);++ return (+ <div className="dbx-blank">+ <div className={`dbx-blank__icon${failed ? ' is-failed' : ''}`}>+ <EngineGlyph entry={instance} size={24} />+ {!failed && <Loader2 size={52} className="dbx-blank__spin dbx-spin" aria-hidden="true" />}+ </div>++ {failed ? (+ <>+ <h2 className="dbx-blank__title">+ <ShieldAlert size={17} aria-hidden="true" /> {instance.name} failed to install+ </h2>+ <p className="dbx-blank__body">+ {instance.error_message+ || 'The deploy did not finish. The install log has the reason.'}+ </p>+ </>+ ) : (+ <>+ <h2 className="dbx-blank__title">Installing {instance.name}</h2>+ <p className="dbx-blank__body">+ Pulling the image, provisioning the volume and waiting for the first health+ check{meta.family ? ` on this ${meta.family.toLowerCase()} engine` : ''}.+ This usually takes about a minute.+ </p>+ </>+ )}++ <div className="dbx-blank__actions">+ {instance.deploy_job_id && (+ <Button asChild size="sm">+ <Link to={`/deployments/${instance.deploy_job_id}`}>+ <Terminal size={14} aria-hidden="true" /> View install log+ </Link>+ </Button>+ )}+ <Button asChild size="sm" variant="outline">+ <Link to="/deployments"><Activity size={14} aria-hidden="true" /> Deploy activity</Link>+ </Button>+ {onRefresh && (+ <Button type="button" size="sm" variant="outline" onClick={onRefresh}>+ <RefreshCw size={14} aria-hidden="true" /> Check again+ </Button>+ )}+ </div>++ {instance.initial_database && (+ <p className="dbx-blank__note">+ <Plus size={12} aria-hidden="true" />+ {instance.initial_database} will be created once the engine reports healthy+ </p>+ )}+ </div>+ );+}++// An engine that is up but has nothing in it yet — either a host engine+// (MySQL / PostgreSQL) with no databases, or a freshly installed one.+export function EngineReadyPanel({ instance, label, onNewDatabase, onOpenConsole }) {+ const meta = engineMeta(instance);+ const address = engineLocation(instance);+ const unitOne = singular(engineUnit(instance));++ return (+ <div className="dbx-blank">+ <div className="dbx-blank__icon">+ <EngineGlyph entry={instance} size={24} />+ </div>+ <h2 className="dbx-blank__title">{label || instance?.name} is ready</h2>+ <p className="dbx-blank__body">+ {address ? <>Listening on <code>{address}</code>. </> : null}+ {onNewDatabase ? (+ 'Create a database to start writing to it.'+ ) : (+ <>+ Create a {unitOne} from {meta.client ? <code>{meta.client}</code> : 'its client'}+ {' '}— ServerKit lists it here as soon as it exists.+ </>+ )}+ </p>+ <div className="dbx-blank__actions">+ {onNewDatabase && (+ <Button type="button" size="sm" onClick={onNewDatabase}>+ <Plus size={14} aria-hidden="true" /> New database+ </Button>+ )}+ {onOpenConsole && (+ <Button type="button" size="sm" variant="outline" onClick={onOpenConsole}>+ <Terminal size={14} aria-hidden="true" /> Open SQL console+ </Button>+ )}+ {instance?.app_id != null && (+ <Button asChild size="sm" variant="outline">+ <Link to={`/services/${instance.app_id}`}>+ <Layers size={14} aria-hidden="true" /> Manage service+ </Link>+ </Button>+ )}+ </div>+ {meta.protocol === 'none' && (+ <p className="dbx-blank__note">+ This engine has no browsable protocol — ServerKit runs it, but table browsing+ comes from its own client.+ </p>+ )}+ </div>+ );+}++// A database that exists but holds no tables/collections yet. The table builder+// and dump import are deliberately out of scope for this round, so the honest+// next step is the console.+export function DatabaseEmptyPanel({ node, unit = 'tables', onOpenConsole }) {+ const unitOne = singular(unit);+ return (+ <div className="dbx-blank">+ <div className="dbx-blank__icon">+ <Table2 size={24} aria-hidden="true" />+ </div>+ <h2 className="dbx-blank__title">No {unit} in {node?.label}</h2>+ <p className="dbx-blank__body">+ The database is connected and empty. Create your first {unitOne} from the console.+ </p>+ <div className="dbx-blank__actions">+ {onOpenConsole && (+ <Button type="button" size="sm" onClick={onOpenConsole}>+ <Terminal size={14} aria-hidden="true" /> Open SQL console+ </Button>+ )}+ </div>+ </div>+ );+}diff --git a/frontend/src/components/databases/EngineCatalogDrawer.jsx b/frontend/src/components/databases/EngineCatalogDrawer.jsxnew file mode 100644index 00000000..3c1c311d--- /dev/null+++ b/frontend/src/components/databases/EngineCatalogDrawer.jsx@@ -0,0 +1,272 @@+import { useMemo, useState } from 'react';+import { Link } from 'react-router-dom';+import {+ Layers, Check, Download, Loader2, PackageX, ShieldAlert, RefreshCw, ChevronRight,+} from 'lucide-react';+import api from '../../services/api';+import { Drawer, SearchField } from '@/components/ds';+import EmptyState from '../EmptyState';+import { useToast } from '../../contexts/ToastContext';+import EngineGlyph from './EngineGlyph';+import {+ engineInstanceKey, engineLocation, engineMeta, engineTreeStatus, familiesOf,+ formatMemory,+} from './engineHelpers';++// "Add a database engine" — the browse half of the install flow.+//+// This component knows the name of no engine. The catalog is every app template+// carrying an `engine:` block, so adding CockroachDB is adding a YAML file:+// families, versions, ports and copy all come off the response. The footer+// links to the full template catalog and to a repository sync, because that is+// how an operator gets an engine ServerKit doesn't ship.+//+// Built on the shared ds/Drawer (Radix Sheet), so Escape, the scrim click and+// focus containment behave like every other drawer in the panel.++function StatusBadge({ status }) {+ if (status === 'installing') {+ return (+ <span className="dbx-eng-badge is-installing">+ <Loader2 size={11} className="dbx-spin" aria-hidden="true" /> installing+ </span>+ );+ }+ if (status === 'failed') {+ return (+ <span className="dbx-eng-badge is-failed">+ <ShieldAlert size={11} aria-hidden="true" /> failed+ </span>+ );+ }+ if (status === 'inactive') return <span className="dbx-eng-badge is-stopped">stopped</span>;+ return (+ <span className="dbx-eng-badge is-running">+ <Check size={11} aria-hidden="true" /> running+ </span>+ );+}++function RunningRow({ instance }) {+ const meta = engineMeta(instance);+ return (+ <li className="dbx-eng-row">+ <span className="dbx-eng-glyph"><EngineGlyph entry={instance} size={16} /></span>+ <span className="dbx-eng-rowtext">+ <span className="dbx-eng-name">{instance.name}</span>+ <span className="dbx-eng-sub">+ {[+ instance.template_name || instance.template_id,+ engineLocation(instance),+ meta.family,+ instance.exposed_public ? 'public' : null,+ ].filter(Boolean).join(' · ')}+ </span>+ </span>+ <StatusBadge status={engineTreeStatus(instance)} />+ </li>+ );+}++function EngineCard({ entry, onPick }) {+ const meta = engineMeta(entry);+ const memory = formatMemory(entry.requirements?.memory);+ const facts = [+ meta.default_port ? `:${meta.default_port}` : null,+ memory ? `${memory} RAM` : null,+ ].filter(Boolean).join(' · ');++ return (+ <li className="dbx-engine-card">+ <button+ type="button"+ className="dbx-engine-card__hit"+ onClick={() => onPick(entry)}+ aria-label={`Install ${entry.name}`}+ >+ <span className="dbx-engine-card__top">+ <span className="dbx-eng-glyph dbx-eng-glyph--lg">+ <EngineGlyph entry={entry} size={20} />+ </span>+ <span className="dbx-eng-rowtext">+ <span className="dbx-eng-name">{entry.name}</span>+ <span className="dbx-eng-sub">+ {[entry.version ? `v${entry.version}` : null, entry.id].filter(Boolean).join(' · ')}+ </span>+ </span>+ {meta.family && <span className="dbx-eng-family">{meta.family}</span>}+ </span>+ <span className="dbx-engine-card__desc">{entry.description}</span>+ <span className="dbx-engine-card__foot">+ <span className="dbx-eng-facts">{facts || ' '}</span>+ <span className="dbx-engine-card__cta">+ <Download size={12} aria-hidden="true" />+ {entry.installed_count > 0 ? 'Add another' : 'Install'}+ </span>+ </span>+ </button>+ </li>+ );+}++export default function EngineCatalogDrawer({+ open,+ onOpenChange,+ catalog = [],+ installed = [],+ // The response carries the family list it derived from the catalog it just+ // built. Deriving it again here is only the fallback.+ families: providedFamilies = null,+ loading = false,+ unavailable = false,+ onPick,+ onSynced,+}) {+ const toast = useToast();+ const [query, setQuery] = useState('');+ const [family, setFamily] = useState(null);+ const [syncing, setSyncing] = useState(false);++ const families = useMemo(+ () => (providedFamilies?.length ? providedFamilies : familiesOf(catalog)),+ [providedFamilies, catalog],+ );++ const results = useMemo(() => {+ const q = query.trim().toLowerCase();+ return catalog.filter((entry) => {+ const meta = engineMeta(entry);+ if (family && meta.family !== family) return false;+ if (!q) return true;+ const haystack = [entry.name, entry.description, entry.id, meta.family, meta.protocol]+ .filter(Boolean).join(' ').toLowerCase();+ return haystack.includes(q);+ });+ }, [catalog, query, family]);++ const filtering = Boolean(query.trim() || family);++ async function syncRepos() {+ setSyncing(true);+ try {+ await api.syncTemplates();+ toast.success('Template repositories synced');+ await onSynced?.();+ } catch (err) {+ toast.error(err.message || 'Could not sync template repositories');+ } finally {+ setSyncing(false);+ }+ }++ return (+ <Drawer+ open={open}+ onOpenChange={onOpenChange}+ title="Add a database engine"+ subtitle={unavailable+ ? 'catalog unavailable'+ : `${catalog.length} engines · same catalog as Services › Templates`}+ icon={<Layers size={18} aria-hidden="true" />}+ width={800}+ className="dbx-drawer"+ >+ <div className="dbx-drawer__shell">+ <div className="dbx-eng-filters">+ <SearchField+ value={query}+ onSearch={setQuery}+ placeholder="Search engines…"+ className="dbx-eng-search"+ />+ {families.length > 0 && (+ <div className="dbx-cat-chips" role="group" aria-label="Filter by family">+ <button+ type="button"+ className={`dbx-cat-chip${family ? '' : ' is-on'}`}+ onClick={() => setFamily(null)}+ aria-pressed={!family}+ >+ All+ </button>+ {families.map((f) => (+ <button+ key={f}+ type="button"+ className={`dbx-cat-chip${family === f ? ' is-on' : ''}`}+ onClick={() => setFamily((cur) => (cur === f ? null : f))}+ aria-pressed={family === f}+ >+ {f}+ </button>+ ))}+ </div>+ )}+ </div>++ <div className="dbx-drawer__scroll">+ {unavailable ? (+ <EmptyState+ icon={PackageX}+ title="Engine catalog unavailable"+ description="This panel couldn't reach the engine catalog. Databases that already exist keep working — try again once the backend is up to date."+ />+ ) : loading ? (+ <EmptyState loading loadingVariant="cards" loadingRows={6} title="Loading engines" />+ ) : (+ <>+ {!filtering && installed.length > 0 && (+ <section className="dbx-eng-section">+ <h3 className="dbx-eyebrow">Already running</h3>+ <ul className="dbx-eng-list">+ {installed.map((inst) => (+ <RunningRow key={engineInstanceKey(inst)} instance={inst} />+ ))}+ </ul>+ </section>+ )}++ <section className="dbx-eng-section">+ <h3 className="dbx-eyebrow">Available to install</h3>+ {results.length === 0 ? (+ <EmptyState+ icon={Layers}+ title={catalog.length === 0 ? 'No engine templates yet' : 'No engines match'}+ description={catalog.length === 0+ ? 'An engine is an app template carrying an engine block. Sync your template repositories to pull more in.'+ : 'Try a different search term or clear the family filter.'}+ />+ ) : (+ <ul className="dbx-engine-grid">+ {results.map((entry) => (+ <EngineCard key={entry.id} entry={entry} onPick={onPick} />+ ))}+ </ul>+ )}+ </section>+ </>+ )}+ </div>++ <footer className="dbx-drawer__foot dbx-drawer__foot--split">+ <button+ type="button"+ className="dbx-inline-link"+ onClick={syncRepos}+ disabled={syncing}+ >+ <RefreshCw size={13} className={syncing ? 'dbx-spin' : undefined} aria-hidden="true" />+ {syncing ? 'Syncing…' : 'Sync template repositories'}+ </button>+ <Link+ className="dbx-inline-link"+ to="/templates"+ onClick={() => onOpenChange(false)}+ >+ Open the full template catalog <ChevronRight size={13} aria-hidden="true" />+ </Link>+ </footer>+ </div>+ </Drawer>+ );+}diff --git a/frontend/src/components/databases/EngineGlyph.jsx b/frontend/src/components/databases/EngineGlyph.jsxnew file mode 100644index 00000000..09ea038b--- /dev/null+++ b/frontend/src/components/databases/EngineGlyph.jsx@@ -0,0 +1,34 @@+import { useState } from 'react';+import { EngineIcon, hasBrandIcon } from '../icons/DatabaseBrands';+import { engineMeta } from './engineHelpers';++// The engine icon, resolved in three steps: the brand glyph we ship, then the+// template's own `icon` URL, then a generic database glyph. Never an emoji —+// the design mock uses them, this panel does not.+//+// A remote icon that 404s falls through to the glyph rather than leaving a+// broken image in the catalog grid.+export function EngineGlyph({ entry, size = 16 }) {+ const [broken, setBroken] = useState(false);++ const id = entry?.id || entry?.template_id;+ if (hasBrandIcon(id)) return <EngineIcon engine={id} size={size} />;++ if (entry?.icon && !broken) {+ return (+ <img+ className="dbx-eng-img"+ src={entry.icon}+ alt=""+ width={size}+ height={size}+ onError={() => setBroken(true)}+ />+ );+ }++ const protocol = engineMeta(entry).protocol;+ return <EngineIcon engine={hasBrandIcon(protocol) ? protocol : 'database'} size={size} />;+}++export default EngineGlyph;diff --git a/frontend/src/components/databases/EngineInstallDrawer.jsx b/frontend/src/components/databases/EngineInstallDrawer.jsxnew file mode 100644index 00000000..87a98b86--- /dev/null+++ b/frontend/src/components/databases/EngineInstallDrawer.jsx@@ -0,0 +1,499 @@+import { useEffect, useMemo, useState } from 'react';+import { useNavigate } from 'react-router-dom';+import {+ Box, Share2, Database, Rocket, Eye, EyeOff, RefreshCw, Copy, ShieldAlert,+ CheckCircle2, HardDrive, RotateCw, Terminal,+} from 'lucide-react';+import api from '../../services/api';+import { Drawer, SegControl } from '@/components/ds';+import { Button } from '@/components/ui/button';+import { Input } from '@/components/ui/input';+import { Switch } from '@/components/ui/switch';+import { useToast } from '../../contexts/ToastContext';+import EngineGlyph from './EngineGlyph';+import {+ engineMeta, engineVersions, generatePassword, partitionVariables, seedVariables,+ singular, slugifyIdent, slugifyService,+} from './engineHelpers';++// "Install <engine>" — the configure half of the install flow.+//+// The form is driven by the template's own `variables[]`, not by a fixed set of+// fields: `type: password` gets the generate/reveal/copy control, `type: port`+// gets a port field, `hidden` variables carry their defaults without a field,+// and `required` is honoured. That is what lets a brand-new engine template+// install with no change here.+//+// Two variables are promoted out of that generic list into purpose-built+// controls because the engine block names them: `admin_password_var` becomes+// the admin-credentials panel, `database_var` becomes "create a database now".+//+// Installing pulls an image, claims a port and writes a data volume, so every+// consequence is on screen before the button — and the public-exposure warning+// is not a matter of taste: it shows whenever the toggle is on.++function SecretRow({ password, onRegenerate, disabled }) {+ const toast = useToast();+ const [revealed, setRevealed] = useState(false);++ const copy = () => {+ navigator.clipboard?.writeText(password).then(+ () => toast.success('Password copied'),+ () => toast.error('Could not copy the password'),+ );+ };++ return (+ <div className="dbx-secret">+ <span className="dbx-secret__value">{revealed ? password : '•'.repeat(20)}</span>+ <span className="dbx-secret__actions">+ <button+ type="button"+ className="dbx-icon-xs"+ onClick={() => setRevealed((r) => !r)}+ aria-label={revealed ? 'Hide password' : 'Reveal password'}+ title={revealed ? 'Hide' : 'Reveal'}+ >+ {revealed ? <EyeOff size={13} aria-hidden="true" /> : <Eye size={13} aria-hidden="true" />}+ </button>+ {onRegenerate && (+ <button+ type="button"+ className="dbx-icon-xs"+ onClick={() => { onRegenerate(); setRevealed(true); }}+ disabled={disabled}+ aria-label="Generate a new password"+ title="Regenerate"+ >+ <RefreshCw size={13} aria-hidden="true" />+ </button>+ )}+ <button+ type="button"+ className="dbx-icon-xs"+ onClick={copy}+ aria-label="Copy password to clipboard"+ title="Copy"+ >+ <Copy size={13} aria-hidden="true" />+ </button>+ </span>+ </div>+ );+}++// One template variable, rendered from its own declaration.+function VariableField({ variable, value, onChange }) {+ const id = `dbx-var-${variable.name}`;+ return (+ <div className="dbx-field">+ <label className="dbx-field__label" htmlFor={id}>+ {variable.name}+ {variable.required && ' *'}+ </label>+ {variable.options ? (+ <select+ id={id}+ value={value ?? ''}+ onChange={(e) => onChange(e.target.value)}+ required={variable.required}+ >+ <option value="">Select…</option>+ {variable.options.map((opt) => <option key={opt} value={opt}>{opt}</option>)}+ </select>+ ) : (+ <Input+ id={id}+ type={variable.type === 'port' ? 'number' : 'text'}+ inputMode={variable.type === 'port' ? 'numeric' : undefined}+ value={value ?? ''}+ onChange={(e) => onChange(e.target.value)}+ placeholder={variable.default != null ? String(variable.default) : ''}+ required={variable.required}+ />+ )}+ {variable.description && <p className="dbx-field-hint">{variable.description}</p>}+ </div>+ );+}++export default function EngineInstallDrawer({ entry, open, onOpenChange, onInstalled }) {+ const toast = useToast();+ const navigate = useNavigate();++ // The list endpoint may carry a summary; the detail endpoint is the one that+ // reliably carries `variables[]`. Fail soft — a summary is still installable.+ const [template, setTemplate] = useState(entry);+ const [name, setName] = useState('');+ const [version, setVersion] = useState('');+ const [vars, setVars] = useState({});+ const [password, setPassword] = useState('');+ const [initialDb, setInitialDb] = useState('');+ const [port, setPort] = useState('');+ const [expose, setExpose] = useState(false);+ const [busy, setBusy] = useState(false);+ const [error, setError] = useState('');+ const [suggestedPort, setSuggestedPort] = useState(null);+ // Set once the install is accepted — credentials are surfaced exactly once.+ const [result, setResult] = useState(null);++ useEffect(() => {+ if (!entry) return undefined;+ let cancelled = false;++ const apply = (tpl) => {+ if (cancelled) return;+ const tplMeta = engineMeta(tpl);+ const tplParts = partitionVariables(tpl);+ const versions = engineVersions(tpl);+ setTemplate(tpl);+ setName(slugifyService(tpl.id || tpl.name));+ setVersion(versions[0] || '');+ setVars(seedVariables(tpl));+ setPassword(tplParts.passwordVar?.default || generatePassword());+ setInitialDb(tplParts.databaseVar?.default ? String(tplParts.databaseVar.default) : '');+ setPort(String(tplParts.portVar?.default ?? tplMeta.default_port ?? ''));+ setExpose(false);+ setError('');+ setSuggestedPort(null);+ setResult(null);+ };++ apply(entry);+ api.getTemplate(entry.id)+ .then((res) => {+ const full = res?.template;+ if (full) apply({ ...entry, ...full, engine: full.engine || entry.engine });+ })+ .catch(() => { /* the summary we already applied is enough to install */ });++ return () => { cancelled = true; };+ }, [entry]);++ const meta = engineMeta(template);+ const parts = useMemo(() => partitionVariables(template), [template]);+ const versionOptions = useMemo(+ () => engineVersions(template).map((v) => ({ value: v, label: v })),+ [template],+ );++ if (!entry || !template) return null;++ const unitOne = singular(meta.unit);+ const dbNoun = unitOne === 'key' ? 'namespace' : 'database';++ function setVar(varName, value) {+ setVars((prev) => ({ ...prev, [varName]: value }));+ }++ async function submit(event) {+ event.preventDefault();+ setError('');+ setSuggestedPort(null);+ setBusy(true);+ try {+ const payload = {+ template_id: template.id,+ instance_name: slugifyService(name),+ // The backend owns the bind address so that a stray `variables`+ // entry can never quietly override private-by-default.+ expose_public: expose,+ variables: { ...vars },+ };+ // Only offered when the template actually declares more than one —+ // sending a version to a template with no image-tag variable is an+ // error, not a no-op.+ if (version && versionOptions.length > 1) payload.version = version;+ if (parts.passwordVar) payload.variables[parts.passwordVar.name] = password;++ // Both of these are top-level: the backend maps them onto the+ // variables the engine block names.+ const db = slugifyIdent(initialDb);+ if (db && parts.databaseVar) payload.initial_database = db;++ const parsedPort = Number.parseInt(port, 10);+ if (Number.isFinite(parsedPort) && parsedPort > 0) payload.port = parsedPort;++ const res = await api.installDatabaseEngine(payload);+ const jobId = res.job_id || res.deploy_job_id || res.job?.id || null;+ // The pipeline may or may not hand back the app row; the caller+ // refreshes either way, so a missing one is not an error.+ const app = res.app || res.application || null;++ toast.success(`Installing ${template.name}`);+ onInstalled?.(app);++ // The admin password is shown once. Navigating straight to the deploy+ // console would take it off screen before it could be copied, so when+ // there is a secret the console is one click away instead of zero.+ if (parts.passwordVar) {+ setResult({ app, jobId, secret: password, warning: res.warning || null });+ } else {+ onOpenChange(false);+ if (jobId) navigate(`/deployments/${jobId}`);+ }+ } catch (err) {+ setError(err.message || 'Failed to start the install');+ if (err.data?.suggested_port) setSuggestedPort(err.data.suggested_port);+ } finally {+ setBusy(false);+ }+ }++ function finish() {+ const jobId = result?.jobId;+ setResult(null);+ onOpenChange(false);+ if (jobId) navigate(`/deployments/${jobId}`);+ }++ return (+ <Drawer+ open={open}+ onOpenChange={(next) => { if (!next) setResult(null); onOpenChange(next); }}+ title={result ? `${template.name} is installing` : `Install ${template.name}`}+ subtitle={[meta.family, template.id, template.version ? `v${template.version}` : null]+ .filter(Boolean).join(' · ')}+ icon={<EngineGlyph entry={template} size={20} />}+ width={560}+ className="dbx-drawer"+ >+ {result ? (+ <div className="dbx-drawer__shell">+ <div className="dbx-drawer__scroll">+ <div className="dbx-result-lead">+ <CheckCircle2 size={16} aria-hidden="true" />+ <span>+ The deploy pipeline is pulling the image and provisioning the volume.+ The engine joins the tree once it reports healthy.+ </span>+ </div>++ <dl className="dbx-kv">+ <div className="dbx-kv__row">+ <dt>Service</dt>+ <dd className="dbx-kv__mono">{result.app?.name || slugifyService(name)}</dd>+ </div>+ {meta.admin_user && (+ <div className="dbx-kv__row">+ <dt>Admin user</dt>+ <dd className="dbx-kv__mono">{meta.admin_user}</dd>+ </div>+ )}+ <div className="dbx-kv__row">+ <dt>Password</dt>+ <dd><SecretRow password={result.secret} /></dd>+ </div>+ </dl>+ <p className="dbx-field-hint">+ Copy the password now — it is stored in ServerKit's secret store and+ is not shown again.+ </p>+ {result.warning && (+ <p className="dbx-warn-line">+ <ShieldAlert size={14} aria-hidden="true" />+ {result.warning}+ </p>+ )}+ </div>+ <footer className="dbx-drawer__foot">+ <Button type="button" onClick={finish}>+ {result.jobId+ ? <><Terminal size={15} aria-hidden="true" /> Open install log</>+ : 'Done'}+ </Button>+ </footer>+ </div>+ ) : (+ <form className="dbx-drawer__shell" onSubmit={submit}>+ <div className="dbx-drawer__scroll">+ {error && (+ <div className="error-message">+ {error}+ {suggestedPort && (+ <>+ {' '}+ <button+ type="button"+ className="dbx-inline-link"+ onClick={() => { setPort(String(suggestedPort)); setError(''); }}+ >+ Use port {suggestedPort}+ </button>+ </>+ )}+ </div>+ )}++ {template.description && (+ <p className="dbx-drawer__lead">{template.description}</p>+ )}++ {versionOptions.length > 1 && (+ <div className="dbx-field">+ <span className="dbx-field__label">Version</span>+ <SegControl options={versionOptions} value={version} onChange={setVersion} />+ </div>+ )}++ <div className="dbx-field">+ <label className="dbx-field__label" htmlFor="dbx-eng-name">Instance name</label>+ <div className="dbx-input">+ <Box size={15} aria-hidden="true" />+ <input+ id="dbx-eng-name"+ type="text"+ value={name}+ onChange={(e) => setName(slugifyService(e.target.value))}+ minLength={2}+ required+ />+ </div>+ <p className="dbx-field-hint">+ Names the service, its container and its data volume.+ </p>+ </div>++ {(parts.portVar || meta.default_port != null) && (+ <div className="dbx-field">+ <label className="dbx-field__label" htmlFor="dbx-eng-port">Port</label>+ <div className="dbx-input">+ <Share2 size={15} aria-hidden="true" />+ <input+ id="dbx-eng-port"+ type="text"+ inputMode="numeric"+ value={port}+ onChange={(e) => setPort(e.target.value.replace(/\D/g, ''))}+ />+ </div>+ {parts.portVar?.description && (+ <p className="dbx-field-hint">{parts.portVar.description}</p>+ )}+ </div>+ )}++ {parts.visible.map((variable) => (+ <VariableField+ key={variable.name}+ variable={variable}+ value={vars[variable.name]}+ onChange={(value) => setVar(variable.name, value)}+ />+ ))}++ {(parts.passwordVar || meta.admin_user) && (+ <div className="dbx-field">+ <span className="dbx-field__label">Admin credentials</span>+ <dl className="dbx-kv">+ {meta.admin_user && (+ <div className="dbx-kv__row">+ <dt>User</dt>+ <dd className="dbx-kv__mono">{meta.admin_user}</dd>+ </div>+ )}+ {parts.passwordVar && (+ <div className="dbx-kv__row">+ <dt>Password</dt>+ <dd>+ <SecretRow+ password={password}+ disabled={busy}+ onRegenerate={() => setPassword(generatePassword())}+ />+ </dd>+ </div>+ )}+ </dl>+ {parts.passwordVar && (+ <p className="dbx-field-hint">+ Shown once. Stored in ServerKit's secret store — never in a log+ or a second API response.+ </p>+ )}+ </div>+ )}++ {/* Only when the engine block names a variable to seed+ it — offering the field otherwise would promise a+ database the template has no way to create. */}+ {parts.databaseVar && (+ <div className="dbx-field">+ <label className="dbx-field__label" htmlFor="dbx-eng-initdb">+ Create a {dbNoun} now+ <span className="dbx-field__optional"> · optional</span>+ </label>+ <div className="dbx-input">+ <Database size={15} aria-hidden="true" />+ <input+ id="dbx-eng-initdb"+ type="text"+ placeholder="app_prod"+ value={initialDb}+ onChange={(e) => setInitialDb(e.target.value)}+ />+ </div>+ <p className="dbx-field-hint">+ Created as soon as the engine passes its health check.+ </p>+ </div>+ )}++ <div className="dbx-field">+ <span className="dbx-field__label">Options</span>+ <div className="dbx-optlist">+ <div className="dbx-opt-row">+ <div className="dbx-opt-row__text">+ <span className="dbx-opt-row__title">Expose on the public network</span>+ <span className="dbx-opt-row__sub">+ {expose+ ? 'The port will be reachable from the internet'+ : 'Bound to 127.0.0.1 only (recommended)'}+ </span>+ </div>+ <Switch+ checked={expose}+ onCheckedChange={setExpose}+ aria-label="Expose on the public network"+ />+ </div>+ {meta.data_path && (+ <div className="dbx-kv__row">+ <dt className="dbx-kv__key">+ <HardDrive size={12} aria-hidden="true" /> Data path+ </dt>+ <dd className="dbx-kv__mono">{meta.data_path}</dd>+ </div>+ )}+ <div className="dbx-kv__row">+ <dt className="dbx-kv__key">+ <RotateCw size={12} aria-hidden="true" /> Restart policy+ </dt>+ <dd className="dbx-kv__ok">unless-stopped</dd>+ </div>+ </div>+ {expose && (+ <p className="dbx-warn-line">+ <ShieldAlert size={14} aria-hidden="true" />+ Public database ports are a common breach vector — prefer the private+ network or an SSH tunnel, and make sure the firewall only admits the+ hosts that need it.+ </p>+ )}+ </div>+ </div>++ <footer className="dbx-drawer__foot">+ <Button type="button" variant="outline" onClick={() => onOpenChange(false)}>+ Cancel+ </Button>+ <Button type="submit" disabled={busy || !slugifyService(name)}>+ <Rocket size={15} aria-hidden="true" />+ {busy ? 'Starting…' : `Install ${template.name}`}+ </Button>+ </footer>+ </form>+ )}+ </Drawer>+ );+}diff --git a/frontend/src/components/databases/SourceTree.jsx b/frontend/src/components/databases/SourceTree.jsxindex 9150f443..335a1e05 100644--- a/frontend/src/components/databases/SourceTree.jsx+++ b/frontend/src/components/databases/SourceTree.jsx@@ -1,9 +1,13 @@-import { ChevronRight, ChevronDown, Table2, Loader2, MoreHorizontal } from 'lucide-react';+import { ChevronRight, ChevronDown, Table2, Loader2, MoreHorizontal, Plus } from 'lucide-react';import { EngineIcon } from '../icons/DatabaseBrands';+import EngineGlyph from './EngineGlyph';// Icon per node kind / engine. Brand glyphs come from DatabaseBrands; tint comes-// from `.is-<engine>` in SCSS (the brand icons use currentColor).+// from `.is-<engine>` in SCSS (the brand icons use currentColor). An engine+// installed from a template carries its catalog entry in `iconEntry`, so it can+// fall back to the template's own icon when we ship no brand glyph for it.function NodeIcon({ node }) {+ if (node.iconEntry) return <EngineGlyph entry={node.iconEntry} size={15} />;if (node.kind === 'engine' || node.kind === 'database') {return <EngineIcon engine={node.engine} size={15} />;}@@ -12,7 +16,13 @@ function NodeIcon({ node }) {return <EngineIcon engine={node.engine} size={15} />;}-const STATUS_LABEL = { active: 'Running', inactive: 'Stopped', missing: 'Not installed' };+const STATUS_LABEL = {+ active: 'Running',+ inactive: 'Stopped',+ missing: 'Not installed',+ installing: 'Installing',+ failed: 'Failed',+};function matches(node, filter) {return !filter || node.label.toLowerCase().includes(filter.toLowerCase());@@ -78,7 +88,9 @@ function TreeRow({ node, depth, expanded, childrenCache, loading, activeKey, sel{node.kind === 'engine' && node.status && node.status !== 'available' && (<span className={`dbx-tree-status is-${node.status}`}>- <span className="dbx-status-dot" aria-hidden="true" />+ {node.status === 'installing'+ ? <Loader2 size={11} className="dbx-spin" aria-hidden="true" />+ : <span className="dbx-status-dot" aria-hidden="true" />}{STATUS_LABEL[node.status]}</span>)}@@ -89,6 +101,19 @@ function TreeRow({ node, depth, expanded, childrenCache, loading, activeKey, sel<span className="dbx-tree-badge">{node.sizeText}</span>)}+ {node.canCreate && handlers.onCreateChild && (+ <button+ type="button"+ className="dbx-tree-add"+ onClick={(e) => { e.stopPropagation(); handlers.onCreateChild(node); }}+ aria-label={`Create a database in ${node.label}`}+ title="Create a database"+ tabIndex={-1}+ >+ <Plus size={12} aria-hidden="true" />+ </button>+ )}+<buttontype="button"className="dbx-tree-more"diff --git a/frontend/src/components/databases/engineHelpers.js b/frontend/src/components/databases/engineHelpers.jsnew file mode 100644index 00000000..c28d5381--- /dev/null+++ b/frontend/src/components/databases/engineHelpers.js@@ -0,0 +1,186 @@+// Shared helpers for the database-engine catalog / install UI.+//+// A database engine IS an app template — one carrying an `engine:` block. So+// nothing here knows the name of a single engine: no catalog, no family list,+// no version list. Everything is derived from what+// `GET /api/v1/databases/engines` returns, which is what lets a brand-new+// engine template work with zero UI changes.++import { hasBrandIcon } from '../icons/DatabaseBrands';++// Templates put their engine metadata in `engine`; an installed engine is an+// Application whose template metadata was resolved onto it the same way.+export function engineMeta(entry) {+ return entry?.engine || {};+}++// Which brand glyph, if any, we hold for this engine. The template id wins over+// the protocol so a Redis-compatible fork keeps its own identity (and falls+// through to its template icon URL) instead of wearing the Redis logo.+export function engineBrandKey(entry) {+ const id = entry?.id || entry?.template_id;+ if (hasBrandIcon(id)) return id;+ if (entry?.icon) return null;+ const protocol = engineMeta(entry).protocol;+ return hasBrandIcon(protocol) ? protocol : null;+}++// Families are whatever the catalog says they are. Sorted alphabetically+// because there is no meaningful order to impose from here.+export function familiesOf(catalog) {+ const present = new Set();+ catalog.forEach((entry) => {+ const family = engineMeta(entry).family;+ if (family) present.add(family);+ });+ return [...present].sort((a, b) => a.localeCompare(b));+}++// An installed engine is an Application, so it is keyed by `app_id`.+export function engineInstanceKey(instance) {+ return instance?.app_id ?? instance?.id ?? null;+}++// App/container status -> the tree's row status vocabulary. Deliberately+// generous: the deploy pipeline and Docker each have their own words for+// "not finished yet" and "broke".+const RUNNING = new Set(['running', 'healthy', 'active', 'up']);+const STOPPED = new Set(['stopped', 'exited', 'inactive', 'paused', 'created']);+const BUSY = new Set(['installing', 'deploying', 'building', 'pending', 'queued', 'starting', 'restarting']);+const BROKEN = new Set(['failed', 'error', 'unhealthy', 'dead']);++export function engineTreeStatus(instance) {+ const appStatus = String(instance?.status || '').toLowerCase();+ // A deploy still running, or one that failed, outranks whatever Docker+ // says — a leftover container from a previous attempt is not "running".+ if (BUSY.has(appStatus)) return 'installing';+ if (BROKEN.has(appStatus)) return 'failed';+ // Otherwise the live container is the truth; the app row is only a record.+ const container = instance?.container;+ if (container) return container.running ? 'active' : 'inactive';+ if (RUNNING.has(appStatus)) return 'active';+ if (STOPPED.has(appStatus)) return 'inactive';+ return 'available';+}++// Service/app names follow the same rule as the template deploy drawer:+// lowercase letters, digits and hyphens.+export function slugifyService(value) {+ return String(value || '')+ .toLowerCase()+ .replace(/[^a-z0-9-]/g, '')+ .replace(/-{2,}/g, '-');+}++// Database identifiers are the other convention — underscores, no hyphens.+export function slugifyIdent(value) {+ return String(value || '')+ .toLowerCase()+ .replace(/[^a-z0-9_]+/g, '_')+ .replace(/_{2,}/g, '_')+ .replace(/^_+|_+$/g, '');+}++// Admin password suggested in the install drawer. Uses the platform CSPRNG —+// Math.random() is not acceptable for something that ends up guarding a+// database port.+const PASSWORD_ALPHABET = 'abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789@%#-';++export function generatePassword(length = 24) {+ const bytes = new Uint32Array(length);+ crypto.getRandomValues(bytes);+ let out = '';+ for (let i = 0; i < length; i += 1) {+ out += PASSWORD_ALPHABET[bytes[i] % PASSWORD_ALPHABET.length];+ }+ return out;+}++// `requirements.memory` is a template field and may be a number of MB or an+// already-formatted string ("512MB"). Render whichever we were handed.+export function formatMemory(value) {+ if (value == null || value === '') return null;+ if (typeof value === 'string') return value;+ return value >= 1024 ? `${Math.round((value / 1024) * 10) / 10} GB` : `${value} MB`;+}++// "collections" -> "collection". Good enough for the unit words an engine block+// uses (tables/collections/keys/buckets/indexes/nodes).+export function singular(unit) {+ if (!unit) return 'table';+ if (unit.endsWith('ies')) return `${unit.slice(0, -3)}y`;+ if (/(x|ch|sh|s)es$/.test(unit)) return unit.slice(0, -2);+ if (unit.endsWith('s')) return unit.slice(0, -1);+ return unit;+}++export function engineUnit(entry) {+ return engineMeta(entry).unit || 'tables';+}++// One line of "where does this thing live" — empty when we genuinely don't+// know, rather than a confident "127.0.0.1" that says nothing.+export function engineLocation(instance) {+ if (!instance) return '';+ const port = instance.port || engineMeta(instance).default_port;+ if (!port) return instance.host || '';+ return `${instance.host || '127.0.0.1'}:${port}`;+}++// Conventional variable names, matching the backend's normalized engine block+// so both ends agree on which variable means what.+const DEFAULT_PORT_VAR = 'PORT';+const DEFAULT_BIND_VAR = 'BIND_ADDRESS';+const DEFAULT_VERSION_VAR = 'IMAGE_TAG';++// The engine block names the variables that carry meaning: the admin secret,+// the initial database, the published port, the bind address, the image tag.+// Each of those gets a purpose-built control (or is set by the backend from+// `expose_public`), so none of them may also appear as a generic field —+// otherwise the same value is asked for twice and answered differently.+export function partitionVariables(entry) {+ const meta = engineMeta(entry);+ const all = entry?.variables || [];+ const byName = (varName) => (varName ? all.find((v) => v.name === varName) || null : null);++ const portVarName = meta.port_var || DEFAULT_PORT_VAR;+ const owned = new Set([+ meta.admin_password_var,+ meta.database_var,+ portVarName,+ meta.bind_var || DEFAULT_BIND_VAR,+ meta.version_var || DEFAULT_VERSION_VAR,+ ].filter(Boolean));++ return {+ passwordVar: byName(meta.admin_password_var),+ databaseVar: byName(meta.database_var),+ portVar: byName(portVarName),+ // Hidden variables still carry their default into the payload; they+ // just don't get a field.+ hidden: all.filter((v) => v.hidden && !owned.has(v.name)),+ visible: all.filter((v) => !v.hidden && !owned.has(v.name)),+ };+}++// Versions the engine offers, resolved by the backend from `engine.versions`+// or the template's own `version`.+export function engineVersions(entry) {+ const meta = engineMeta(entry);+ if (Array.isArray(meta.versions) && meta.versions.length) return meta.versions;+ return entry?.version ? [String(entry.version)] : [];+}++// Seed every variable from its declared default; a password variable with no+// default gets a generated one so the operator can copy it before install.+export function seedVariables(entry) {+ const seeded = {};+ (entry?.variables || []).forEach((v) => {+ if (v.type === 'password') {+ seeded[v.name] = v.default || generatePassword();+ } else if (v.default != null) {+ seeded[v.name] = String(v.default);+ }+ });+ return seeded;+}diff --git a/frontend/src/components/databases/modals.jsx b/frontend/src/components/databases/modals.jsxindex e2ebcdec..4646f154 100644--- a/frontend/src/components/databases/modals.jsx+++ b/frontend/src/components/databases/modals.jsx@@ -1,8 +1,11 @@-import { useState } from 'react';+import { useEffect, useState } from 'react';+import { Plus } from 'lucide-react';import api from '../../services/api';import Modal from '@/components/Modal';import { Button } from '@/components/ui/button';import { Input } from '@/components/ui/input';+import { EngineIcon } from '../icons/DatabaseBrands';+import { ENGINE_META } from './dbAdapter';// Create / credentials modals for the explorer. Logic is unchanged from the// original Databases page; the explorer wires them to its toolbar and tree.@@ -29,18 +32,100 @@ function CredentialsResult({ title, rows, onDone }) {);}-export function CreateMySQLDatabaseModal({ onClose, onCreated }) {- const [formData, setFormData] = useState({ name: '', charset: 'utf8mb4', collation: 'utf8mb4_unicode_ci', create_user: true, user_password: '' });+// One "New database" modal for every engine the panel can create into, rather+// than one modal per engine. It adds two things the old pair never surfaced:+//+// * an engine picker, with a route out to the engine catalog when the engine+// you want isn't installed yet;+// * "Attach to application", which sends `application_id` — the create+// endpoints have always accepted it, the UI simply never offered it, so+// every database created here was born unowned.+//+// Only host MySQL / PostgreSQL accept a create call today. Engines installed+// from the catalog run as their own service and are reached through their own+// client, so listing them here as pickable would be a promise we can't keep.+const CREATABLE_ENGINES = ['mysql', 'postgresql'];++function EnginePicker({ value, onChange, status, onInstallEngine }) {+ return (+ <div className="dbx-eng-pick">+ {CREATABLE_ENGINES.map((engine) => {+ const running = Boolean(status?.[engine]?.installed && status?.[engine]?.running);+ return (+ <button+ key={engine}+ type="button"+ className={`dbx-eng-opt${value === engine ? ' is-on' : ''}`}+ onClick={() => onChange(engine)}+ disabled={!running}+ title={running ? undefined : `${ENGINE_META[engine].label} is not running`}+ >+ <span className={`dbx-eng-opt__ico is-${engine}`}>+ <EngineIcon engine={engine} size={16} />+ </span>+ <span className="dbx-eng-opt__text">+ <span className="dbx-eng-opt__name">{ENGINE_META[engine].label}</span>+ <span className="dbx-eng-opt__sub">{running ? 'running' : 'not running'}</span>+ </span>+ </button>+ );+ })}+ {onInstallEngine && (+ <button+ type="button"+ className="dbx-eng-opt dbx-eng-opt--ghost"+ onClick={onInstallEngine}+ >+ <span className="dbx-eng-opt__ico"><Plus size={16} aria-hidden="true" /></span>+ <span className="dbx-eng-opt__text">+ <span className="dbx-eng-opt__name">Install an engine</span>+ <span className="dbx-eng-opt__sub">from the template catalog</span>+ </span>+ </button>+ )}+ </div>+ );+}++export function CreateDatabaseModal({ engine: initialEngine = 'mysql', status, onClose, onCreated, onInstallEngine }) {+ const [engine, setEngine] = useState(initialEngine);+ const [formData, setFormData] = useState({+ name: '', charset: 'utf8mb4', collation: 'utf8mb4_unicode_ci', encoding: 'UTF8', create_user: true,+ });+ const [applicationId, setApplicationId] = useState('');+ const [apps, setApps] = useState([]);+ const [appsLoading, setAppsLoading] = useState(true);const [loading, setLoading] = useState(false);const [error, setError] = useState('');const [createdInfo, setCreatedInfo] = useState(null);+ // Attaching is optional, so a failed app lookup must not block the create —+ // the selector just stays empty.+ useEffect(() => {+ let cancelled = false;+ api.getApps()+ .then((d) => { if (!cancelled) setApps(d.apps || []); })+ .catch(() => { if (!cancelled) setApps([]); })+ .finally(() => { if (!cancelled) setAppsLoading(false); });+ return () => { cancelled = true; };+ }, []);++ const isMySQL = engine === 'mysql';+async function handleSubmit(e) {e.preventDefault();setError('');setLoading(true);try {- const result = await api.createMySQLDatabase(formData);+ const payload = isMySQL+ ? { name: formData.name, charset: formData.charset, collation: formData.collation, create_user: formData.create_user }+ : { name: formData.name, encoding: formData.encoding, create_user: formData.create_user };+ if (applicationId) payload.application_id = Number(applicationId);++ const result = isMySQL+ ? await api.createMySQLDatabase(payload)+ : await api.createPostgreSQLDatabase(payload);+if (result.success) {if (result.password) setCreatedInfo({ database: formData.name, user: result.user, password: result.password });else { onCreated(); onClose(); }@@ -53,41 +138,88 @@ export function CreateMySQLDatabaseModal({ onClose, onCreated }) {}if (createdInfo) {+ const attached = apps.find((a) => String(a.id) === String(applicationId));return (<CredentialsResulttitle="Database created"- rows={[['Database', createdInfo.database], ['Username', createdInfo.user], ['Password', createdInfo.password]]}+ rows={[+ ['Database', createdInfo.database],+ ['Username', createdInfo.user],+ ['Password', createdInfo.password],+ ...(attached ? [['Attached to', attached.name]] : []),+ ]}onDone={() => { onCreated(); onClose(); }}/>);}return (- <Modal open onClose={onClose} title="Create MySQL database">+ <Modal open onClose={onClose} title="New database">{error && <div className="error-message">{error}</div>}<form onSubmit={handleSubmit}>+ <div className="form-group">+ <label>Engine</label>+ <EnginePicker+ value={engine}+ onChange={setEngine}+ status={status}+ onInstallEngine={onInstallEngine ? () => { onClose(); onInstallEngine(); } : null}+ />+ </div>+<div className="form-group"><label>Database name *</label><Input type="text" value={formData.name} onChange={(e) => setFormData({ ...formData, name: e.target.value })} placeholder="my_database" required pattern="[a-zA-Z0-9_]+" autoFocus /></div>- <div className="form-row">- <div className="form-group">- <label>Character set</label>- <select value={formData.charset} onChange={(e) => setFormData({ ...formData, charset: e.target.value })}>- <option value="utf8mb4">utf8mb4</option>- <option value="utf8">utf8</option>- <option value="latin1">latin1</option>- </select>++ {isMySQL ? (+ <div className="form-row">+ <div className="form-group">+ <label>Character set</label>+ <select value={formData.charset} onChange={(e) => setFormData({ ...formData, charset: e.target.value })}>+ <option value="utf8mb4">utf8mb4</option>+ <option value="utf8">utf8</option>+ <option value="latin1">latin1</option>+ </select>+ </div>+ <div className="form-group">+ <label>Collation</label>+ <select value={formData.collation} onChange={(e) => setFormData({ ...formData, collation: e.target.value })}>+ <option value="utf8mb4_unicode_ci">utf8mb4_unicode_ci</option>+ <option value="utf8mb4_general_ci">utf8mb4_general_ci</option>+ <option value="utf8_general_ci">utf8_general_ci</option>+ </select>+ </div></div>+ ) : (<div className="form-group">- <label>Collation</label>- <select value={formData.collation} onChange={(e) => setFormData({ ...formData, collation: e.target.value })}>- <option value="utf8mb4_unicode_ci">utf8mb4_unicode_ci</option>- <option value="utf8mb4_general_ci">utf8mb4_general_ci</option>- <option value="utf8_general_ci">utf8_general_ci</option>+ <label>Encoding</label>+ <select value={formData.encoding} onChange={(e) => setFormData({ ...formData, encoding: e.target.value })}>+ <option value="UTF8">UTF8</option>+ <option value="LATIN1">LATIN1</option>+ <option value="SQL_ASCII">SQL_ASCII</option></select></div>+ )}++ <div className="form-group">+ <label htmlFor="dbx-attach-app">Attach to application</label>+ <select+ id="dbx-attach-app"+ value={applicationId}+ onChange={(e) => setApplicationId(e.target.value)}+ disabled={appsLoading}+ >+ <option value="">— None —</option>+ {apps.map((app) => <option key={app.id} value={app.id}>{app.name}</option>)}+ </select>+ <span className="form-help">+ {appsLoading+ ? 'Loading applications…'+ : 'Optional. An attached database is listed on the application and is cleaned up with it.'}+ </span></div>+<div className="form-group"><label className="checkbox-label"><input type="checkbox" checked={formData.create_user} onChange={(e) => setFormData({ ...formData, create_user: e.target.checked })} />@@ -181,70 +313,6 @@ export function CreateMySQLUserModal({ databases, onClose, onCreated }) {);}-export function CreatePostgreSQLDatabaseModal({ onClose, onCreated }) {- const [formData, setFormData] = useState({ name: '', encoding: 'UTF8', create_user: true });- const [loading, setLoading] = useState(false);- const [error, setError] = useState('');- const [createdInfo, setCreatedInfo] = useState(null);-- async function handleSubmit(e) {- e.preventDefault();- setError('');- setLoading(true);- try {- const result = await api.createPostgreSQLDatabase(formData);- if (result.success) {- if (result.password) setCreatedInfo({ database: formData.name, user: result.user, password: result.password });- else { onCreated(); onClose(); }- }- } catch (err) {- setError(err.message || 'Failed to create database');- } finally {- setLoading(false);- }- }-- if (createdInfo) {- return (- <CredentialsResult- title="Database created"- rows={[['Database', createdInfo.database], ['Username', createdInfo.user], ['Password', createdInfo.password]]}- onDone={() => { onCreated(); onClose(); }}- />- );- }-- return (- <Modal open onClose={onClose} title="Create PostgreSQL database">- {error && <div className="error-message">{error}</div>}- <form onSubmit={handleSubmit}>- <div className="form-group">- <label>Database name *</label>- <Input type="text" value={formData.name} onChange={(e) => setFormData({ ...formData, name: e.target.value })} placeholder="my_database" required autoFocus />- </div>- <div className="form-group">- <label>Encoding</label>- <select value={formData.encoding} onChange={(e) => setFormData({ ...formData, encoding: e.target.value })}>- <option value="UTF8">UTF8</option>- <option value="LATIN1">LATIN1</option>- <option value="SQL_ASCII">SQL_ASCII</option>- </select>- </div>- <div className="form-group">- <label className="checkbox-label">- <input type="checkbox" checked={formData.create_user} onChange={(e) => setFormData({ ...formData, create_user: e.target.checked })} />- Create user with same name and full privileges- </label>- </div>- <div className="modal-actions">- <Button type="button" variant="outline" onClick={onClose}>Cancel</Button>- <Button type="submit" disabled={loading}>{loading ? 'Creating…' : 'Create database'}</Button>- </div>- </form>- </Modal>- );-}-export function CreatePostgreSQLUserModal({ databases, onClose, onCreated }) {const [formData, setFormData] = useState({ username: '', password: '', database: '' });const [loading, setLoading] = useState(false);diff --git a/frontend/src/pages/Databases.jsx b/frontend/src/pages/Databases.jsxindex e9a34d52..2201b181 100644--- a/frontend/src/pages/Databases.jsx+++ b/frontend/src/pages/Databases.jsx@@ -1,9 +1,10 @@import { useState, useEffect, useMemo, useCallback, useRef } from 'react';+import { useNavigate } from 'react-router-dom';import {PanelLeftClose, PanelLeftOpen, Search, X, RefreshCw, Plus, Terminal,Archive, Database, Table2, Server, ChevronDown,Trash2, DatabaseBackup, Copy, FileCode2, Lock, BookMarked, Activity,- SlidersHorizontal,+ SlidersHorizontal, Layers, ExternalLink,} from 'lucide-react';import api from '../services/api';import Modal from '@/components/Modal';@@ -19,9 +20,16 @@ import BackupsTab from '../components/databases/BackupsTab';import ProcessListPanel from '../components/databases/ProcessListPanel';import ConfigTunerPanel from '../components/databases/ConfigTunerPanel';import {- CreateMySQLDatabaseModal, CreateMySQLUserModal,- CreatePostgreSQLDatabaseModal, CreatePostgreSQLUserModal,+ CreateDatabaseModal, CreateMySQLUserModal, CreatePostgreSQLUserModal,} from '../components/databases/modals';+import EngineCatalogDrawer from '../components/databases/EngineCatalogDrawer';+import EngineInstallDrawer from '../components/databases/EngineInstallDrawer';+import {+ EngineInstallingPanel, EngineReadyPanel, DatabaseEmptyPanel,+} from '../components/databases/DbBlankStates';+import {+ engineBrandKey, engineInstanceKey, engineTreeStatus, engineUnit,+} from '../components/databases/engineHelpers';import { listTables, connKey, connLabel, quoteIdent, ENGINE_META } from '../components/databases/dbAdapter';const SIDEBAR_KEY = 'serverkit-dbx-sidebar';@@ -68,6 +76,7 @@ function TabIcon({ tab }) {export default function Databases() {const toast = useToast();const { confirm } = useConfirm();+ const navigate = useNavigate();const [status, setStatus] = useState(null);const [statusLoading, setStatusLoading] = useState(true);@@ -89,6 +98,15 @@ export default function Databases() {const [showManaged, setShowManaged] = useState(false);const [tunerTarget, setTunerTarget] = useState(null);const [modal, setModal] = useState(null); // { type, databases }+ // Engine catalog + the engines installed from it. `unavailable` is the+ // fail-soft state: the four built-in roots keep working without it.+ const [engineData, setEngineData] = useState({ catalog: [], installed: [], unavailable: false });+ const [enginesLoading, setEnginesLoading] = useState(true);+ const [catalogOpen, setCatalogOpen] = useState(false);+ const [installEntry, setInstallEntry] = useState(null);+ // What the workspace shows when there is no tab to show: an engine that is+ // still installing, an engine that is up but empty, an empty database.+ const [blank, setBlank] = useState(null);const newMenuRef = useRef(null);const didAutoExpand = useRef(false);@@ -111,14 +129,60 @@ export default function Databases() {})();}, []);+ // The engine catalog is optional: an older backend simply doesn't serve it,+ // and the explorer has to keep working on its four built-in roots.+ const loadEngines = useCallback(async () => {+ try {+ const d = await api.getDatabaseEngines();+ setEngineData({+ catalog: d.catalog || [],+ installed: d.installed || [],+ // The backend derives the family list from the catalog it just+ // built; deriving it again here would be a second source.+ families: d.families || null,+ unavailable: false,+ });+ } catch {+ setEngineData({ catalog: [], installed: [], families: null, unavailable: true });+ } finally {+ setEnginesLoading(false);+ }+ }, []);++ useEffect(() => { loadEngines(); }, [loadEngines]);++ // Poll only while a deploy is in flight, so an `installing` row flips to+ // `running` on its own instead of waiting for a manual refresh.+ const installingCount = engineData.installed.filter(+ (e) => engineTreeStatus(e) === 'installing',+ ).length;+ useEffect(() => {+ if (!installingCount) return undefined;+ const timer = setInterval(loadEngines, 4000);+ return () => clearInterval(timer);+ }, [installingCount, loadEngines]);+const roots = useMemo(() => ([// mysql/postgresql stay expandable even when the host engine is absent —// they can still contain databases that live in Docker containers.- { id: 'eng:mysql', kind: 'engine', engine: 'mysql', label: ENGINE_META.mysql.label, status: engineState('mysql', status), expandable: true },- { id: 'eng:postgresql', kind: 'engine', engine: 'postgresql', label: ENGINE_META.postgresql.label, status: engineState('postgresql', status), expandable: true },+ { id: 'eng:mysql', kind: 'engine', engine: 'mysql', label: ENGINE_META.mysql.label, status: engineState('mysql', status), expandable: true, canCreate: engineState('mysql', status) === 'active' },+ { id: 'eng:postgresql', kind: 'engine', engine: 'postgresql', label: ENGINE_META.postgresql.label, status: engineState('postgresql', status), expandable: true, canCreate: engineState('postgresql', status) === 'active' },{ id: 'eng:sqlite', kind: 'engine', engine: 'sqlite', label: ENGINE_META.sqlite.label, status: 'available', expandable: true },{ id: 'eng:docker', kind: 'engine', engine: 'docker', label: ENGINE_META.docker.label, status: 'available', expandable: true },- ]), [status]);+ // Engines installed from the template catalog join the built-in roots+ // rather than replacing them. They are leaves: each runs as its own+ // service, and selecting one shows its state in the workspace.+ ...engineData.installed.map((inst) => ({+ id: `dbe:${engineInstanceKey(inst)}`,+ kind: 'engine',+ engine: engineBrandKey(inst) || 'database',+ iconEntry: inst,+ label: inst.name || inst.instance_name || inst.template_id,+ status: engineTreeStatus(inst),+ expandable: false,+ instance: inst,+ })),+ ]), [status, engineData.installed]);// ─── lazy child loading ───────────────────────────────────const loadChildren = useCallback(async (node) => {@@ -223,18 +287,25 @@ export default function Databases() {setTabStatuses((prev) => ({ ...prev, [tabId]: s }));}, []);+ // Opening any tab takes the workspace out of a blank state — the blank pane+ // and the tab panes are alternatives, not neighbours.+ function showTab(id) {+ setBlank(null);+ setActiveTabId(id);+ }+function openTableTab(node) {const id = `tbl:${connKey(node.conn)}:${node.table}`;setTabs((prev) => prev.some((t) => t.id === id) ? prev: [...prev, { id, kind: 'table', title: node.table, conn: node.conn, table: node.table, rows: node.rows, engine: node.engine }]);- setActiveTabId(id);+ showTab(id);}function openConsole(conn, engine, initialQuery = '') {const id = `con:${connKey(conn)}`;setTabs((prev) => prev.some((t) => t.id === id) ? prev: [...prev, { id, kind: 'console', title: `${connLabel(conn)}`, conn, engine, initialQuery }]);- setActiveTabId(id);+ showTab(id);}function openProcesses(conn, engine) {@@ -244,12 +315,12 @@ export default function Databases() {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);+ showTab(id);}function openBackups() {setTabs((prev) => prev.some((t) => t.id === 'backups') ? prev : [...prev, { id: 'backups', kind: 'backups', title: 'Backups' }]);- setActiveTabId('backups');+ showTab('backups');}function closeTab(id, e) {@@ -269,14 +340,41 @@ export default function Databases() {function activate(node) {setSelectedNode(node);- if (node.kind === 'table') openTableTab(node);- else if (node.kind === 'database') {- // single click opens the database's SQL console (it used to be- // reachable only via the context menu) and expands its tables;- // collapsing stays on the chevron so re-clicks don't fold the tree+ if (node.kind === 'table') { openTableTab(node); return; }++ // An engine installed from the catalog is a leaf: there is nothing to+ // expand, so selecting it shows what that engine is doing.+ if (node.kind === 'engine' && node.instance) {+ setBlank({ kind: 'engine', instanceId: engineInstanceKey(node.instance) });+ setActiveTabId(null);+ return;+ }++ const kids = childrenCache.get(node.id);+ const knownEmpty = Array.isArray(kids) && kids.length === 0;++ if (node.kind === 'database') {+ // Once we know a database holds nothing, say so instead of opening a+ // console onto an empty schema. Until then, single click opens the+ // console and expands its tables; collapsing stays on the chevron so+ // re-clicks don't fold the tree.+ if (knownEmpty) {+ setBlank({ kind: 'database', node });+ setActiveTabId(null);+ return;+ }openConsole(node.conn, node.engine);if (node.expandable && !expanded.has(node.id)) toggle(node);- } else if (node.expandable) toggle(node);+ return;+ }++ if (node.kind === 'engine' && knownEmpty && node.status === 'active') {+ setBlank({ kind: 'host-engine', node });+ setActiveTabId(null);+ return;+ }++ if (node.expandable) toggle(node);}// ─── tree context menu ────────────────────────────────────@@ -341,6 +439,16 @@ export default function Databases() {function ctxActions(node) {switch (node.kind) {case 'engine':+ // An engine installed from a template is an app: its lifecycle+ // lives on the service page rather than being duplicated here.+ if (node.instance) {+ const appId = engineInstanceKey(node.instance);+ return [+ { label: 'Open service', icon: ExternalLink, onClick: () => navigate(`/services/${appId}`) },+ { label: 'Deploy activity', icon: Activity, onClick: () => navigate('/deployments') },+ { label: 'Refresh', icon: RefreshCw, onClick: () => loadEngines() },+ ];+ }if (node.engine === 'mysql' && node.status === 'active') {return [{ label: 'Create database', icon: Plus, onClick: () => setModal({ type: 'mysql-db' }) },@@ -405,13 +513,36 @@ export default function Databases() {if (eng) refresh(eng);}+ // A freshly installed engine goes straight into the tree and the workspace,+ // so the install has somewhere to land instead of leaving the drawer and+ // nothing to show for it. The install pipeline doesn't always hand back the+ // app row — when it doesn't, the refresh alone is enough.+ function onEngineInstalled(app) {+ loadEngines();+ const appId = app?.app_id ?? app?.id;+ if (typeof appId === 'number') {+ setBlank({ kind: 'engine', instanceId: appId });+ setActiveTabId(null);+ }+ }+const newConsoleConn = selectedNode?.conn || null;const activeStatus = tabStatuses[activeTabId];+ // Blank-state subjects are re-resolved from the latest poll, so an+ // `installing` panel becomes a `ready` panel without any extra wiring.+ const blankInstance = useMemo(() => {+ if (blank?.kind !== 'engine') return null;+ return engineData.installed.find(+ (e) => engineInstanceKey(e) === blank.instanceId,+ ) || null;+ }, [blank, engineData.installed]);+const treeHandlers = useMemo(() => ({onToggle: toggle,onActivate: activate,onContext: openContext,+ onCreateChild: (node) => setModal({ type: node.engine === 'mysql' ? 'mysql-db' : 'pg-db' }),}), [toggle]); // eslint-disable-line react-hooks/exhaustive-depsreturn (@@ -467,6 +598,10 @@ export default function Databases() {<button type="button" role="menuitem" disabled={engineState('postgresql', status) !== 'active'} onClick={() => { openUserModal('postgresql'); setShowNewMenu(false); }}><Server size={14} aria-hidden="true" /> PostgreSQL user</button>+ <div className="dbx-menu-sep" />+ <button type="button" role="menuitem" onClick={() => { setCatalogOpen(true); setShowNewMenu(false); }}>+ <Layers size={14} aria-hidden="true" /> Install a database engine…+ </button></div>)}</div>@@ -500,16 +635,30 @@ export default function Databases() {{statusLoading ? (<div className="dbx-tree-loading"><RefreshCw size={14} className="dbx-spin" aria-hidden="true" /> Checking servers…</div>) : (- <SourceTree- roots={roots}- expanded={expanded}- childrenCache={childrenCache}- loading={loadingNodes}- activeKey={null}- selectedId={selectedNode?.id}- filter={filter}- handlers={treeHandlers}- />+ <>+ <SourceTree+ roots={roots}+ expanded={expanded}+ childrenCache={childrenCache}+ loading={loadingNodes}+ activeKey={null}+ selectedId={selectedNode?.id}+ filter={filter}+ handlers={treeHandlers}+ />+ {/* The way to get an engine the tree doesn't+ list yet, right where you notice it's+ missing. */}+ {!engineData.unavailable && (+ <button+ type="button"+ className="dbx-tree-install"+ onClick={() => setCatalogOpen(true)}+ >+ <Layers size={14} aria-hidden="true" /> Install a database engine+ </button>+ )}+ </>)}</div></aside>@@ -525,8 +674,8 @@ export default function Databases() {aria-selected={tab.id === activeTabId}tabIndex={0}className={`dbx-tab is-${tab.engine || tab.kind} ${tab.id === activeTabId ? 'is-active' : ''}`}- onClick={() => setActiveTabId(tab.id)}- onKeyDown={(e) => { if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); setActiveTabId(tab.id); } }}+ onClick={() => showTab(tab.id)}+ onKeyDown={(e) => { if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); showTab(tab.id); } }}><TabIcon tab={tab} /><span className="dbx-tab-title">{tab.title}</span>@@ -554,7 +703,34 @@ export default function Databases() {)}<div className="dbx-panes">- {tabs.length === 0 ? (+ {blank ? (+ <>+ {blank.kind === 'engine' && blankInstance && (+ engineTreeStatus(blankInstance) === 'installing'+ || engineTreeStatus(blankInstance) === 'failed'+ ? <EngineInstallingPanel instance={blankInstance} onRefresh={loadEngines} />+ : <EngineReadyPanel instance={blankInstance} />+ )}+ {blank.kind === 'host-engine' && (+ <EngineReadyPanel+ // `id` is what resolves the brand glyph, and a+ // built-in root's id is a tree id, not an engine key.+ instance={{ id: blank.node.engine, name: blank.node.label }}+ label={blank.node.label}+ onNewDatabase={() => setModal({+ type: blank.node.engine === 'mysql' ? 'mysql-db' : 'pg-db',+ })}+ />+ )}+ {blank.kind === 'database' && (+ <DatabaseEmptyPanel+ node={blank.node}+ unit={engineUnit(blank.node)}+ onOpenConsole={() => openConsole(blank.node.conn, blank.node.engine)}+ />+ )}+ </>+ ) : tabs.length === 0 ? (<div className="dbx-welcome"><EmptyStateicon={Database}@@ -564,9 +740,12 @@ export default function Databases() {: 'Pick a table from the left to browse its rows, or open a SQL console on any database. Right-click a node for more actions.'}/></div>- ) : (- tabs.map((tab) => (- <div key={tab.id} className="dbx-tabpane" hidden={tab.id !== activeTabId}>+ ) : null}++ {/* Panes stay mounted behind a blank state — a half-typed+ query must survive a click on the tree. */}+ {tabs.map((tab) => (+ <div key={tab.id} className="dbx-tabpane" hidden={Boolean(blank) || tab.id !== activeTabId}>{tab.kind === 'console' && (<ConsoleTabconn={tab.conn}@@ -598,8 +777,7 @@ export default function Databases() {)}{tab.kind === 'backups' && <BackupsTab />}</div>- ))- )}+ ))}</div></main></div>@@ -649,11 +827,37 @@ export default function Databases() {)}{/* ─── Modals ─────────────────────────────────── */}- {modal?.type === 'mysql-db' && <CreateMySQLDatabaseModal onClose={() => setModal(null)} onCreated={onModalCreated} />}- {modal?.type === 'pg-db' && <CreatePostgreSQLDatabaseModal onClose={() => setModal(null)} onCreated={onModalCreated} />}+ {(modal?.type === 'mysql-db' || modal?.type === 'pg-db') && (+ <CreateDatabaseModal+ engine={modal.type === 'mysql-db' ? 'mysql' : 'postgresql'}+ status={status}+ onClose={() => setModal(null)}+ onCreated={onModalCreated}+ onInstallEngine={() => setCatalogOpen(true)}+ />+ )}{modal?.type === 'mysql-user' && <CreateMySQLUserModal databases={modal.databases} onClose={() => setModal(null)} onCreated={onModalCreated} />}{modal?.type === 'pg-user' && <CreatePostgreSQLUserModal databases={modal.databases} onClose={() => setModal(null)} onCreated={onModalCreated} />}+ {/* ─── Engine catalog + install ───────────────── */}+ <EngineCatalogDrawer+ open={catalogOpen}+ onOpenChange={setCatalogOpen}+ catalog={engineData.catalog}+ installed={engineData.installed}+ families={engineData.families}+ loading={enginesLoading}+ unavailable={engineData.unavailable}+ onSynced={loadEngines}+ onPick={(entry) => { setCatalogOpen(false); setInstallEntry(entry); }}+ />+ <EngineInstallDrawer+ entry={installEntry}+ open={Boolean(installEntry)}+ onOpenChange={(next) => { if (!next) setInstallEntry(null); }}+ onInstalled={onEngineInstalled}+ />+<Modal open={showManaged} onClose={() => setShowManaged(false)} title="Managed databases" size="lg"><ManagedDatabasesPanel /></Modal>diff --git a/frontend/src/services/api/databases.js b/frontend/src/services/api/databases.jsindex 6c19bd69..1d12c199 100644--- a/frontend/src/services/api/databases.js+++ b/frontend/src/services/api/databases.js@@ -282,3 +282,18 @@ export async function deleteManagedDbUser(id, userId) {export async function launchManagedDbSso(id) {return this.request(`/managed-databases/${id}/sso`, { method: 'POST' });}++// Database engines. An engine is an app template carrying an `engine:` block,+// so this is a view over the template catalog plus the apps installed from it —+// `{ catalog: [...], installed: [...] }`. Installing delegates to the ordinary+// template install pipeline and answers with the app and its deployment job, so+// the caller navigates to the deploy console like any other template install.+//+// Lifecycle (start / stop / uninstall) is app lifecycle: use the app endpoints.+export async function getDatabaseEngines() {+ return this.request('/databases/engines');+}++export async function installDatabaseEngine(payload) {+ return this.request('/databases/engines', { method: 'POST', body: payload });+}diff --git a/frontend/src/styles/pages/_databases.scss b/frontend/src/styles/pages/_databases.scssindex cdc23e51..37141cb9 100644--- a/frontend/src/styles/pages/_databases.scss+++ b/frontend/src/styles/pages/_databases.scss@@ -960,6 +960,145 @@ $dbx-sqlite: #3d8fd1;}}+ // ─── Engine install affordances (tree) ────────────────+ // A "+" that only surfaces on the row you are pointing at, so the tree stays+ // a tree until you reach for it.+ .dbx-tree-add {+ flex-shrink: 0;+ display: flex;+ align-items: center;+ justify-content: center;+ width: 18px;+ height: 18px;+ padding: 0;+ background: $bg-tertiary;+ border: none;+ border-radius: $radius-sm;+ color: $text-tertiary;+ cursor: pointer;+ opacity: 0;+ transition: opacity $transition-fast, background $transition-fast, color $transition-fast;++ &:hover { background: $accent-primary; color: #fff; }+ }+ .dbx-tree-row:hover .dbx-tree-add,+ .dbx-tree-row:focus-within .dbx-tree-add { opacity: 1; }++ .dbx-tree-status.is-installing { color: $warning; }+ .dbx-tree-status.is-failed { color: $danger; }+ .dbx-tree-row.is-installing .dbx-tree-label { color: $warning; }++ // The last row of the tree: how you get an engine the tree doesn't list.+ // Dashed, because it adds to the tree rather than being part of it.+ .dbx-tree-install {+ display: flex;+ align-items: center;+ gap: $space-2;+ width: 100%;+ margin: $space-2 0 $space-1;+ padding: $space-2 $space-3;+ background: transparent;+ border: 1px dashed $border-active;+ border-radius: $radius-md;+ color: $text-tertiary;+ font-size: $font-size-sm;+ text-align: left;+ cursor: pointer;+ transition: color $transition-fast, border-color $transition-fast, background $transition-fast;++ &:hover {+ color: $accent-primary;+ border-color: $accent-primary;+ background: $accent-glow;+ }+ svg { flex-shrink: 0; }+ }++ // ─── Main-pane blank states ───────────────────────────+ // Reachable three ways: an engine mid-install, an engine that is up but+ // empty, a database with nothing in it.+ .dbx-blank {+ flex: 1;+ display: flex;+ flex-direction: column;+ align-items: center;+ justify-content: center;+ text-align: center;+ padding: $space-8 $space-5;++ &__icon {+ position: relative;+ display: grid;+ place-items: center;+ width: 52px;+ height: 52px;+ margin-bottom: $space-4;+ background: $bg-elevated;+ border: 1px solid $border-default;+ border-radius: $radius-lg;+ color: $text-secondary;++ &.is-failed { border-color: $danger-border; color: $danger; }+ }++ // The ring turns the engine glyph itself into the progress indicator,+ // rather than parking a second spinner beside it.+ &__spin {+ position: absolute;+ inset: -7px;+ width: auto;+ height: auto;+ color: $warning;+ }++ &__title {+ display: inline-flex;+ align-items: center;+ gap: $space-2;+ margin: 0;+ font-size: $font-size-lg;+ font-weight: $font-weight-semibold;+ color: $text-primary;+ }++ &__body {+ max-width: 46ch;+ margin: $space-2 0 0;+ color: $text-secondary;+ font-size: $font-size-sm;+ line-height: 1.6;++ code {+ padding: 1px 5px;+ border-radius: $radius-sm;+ background: $bg-tertiary;+ font-family: $font-mono;+ font-size: $font-size-xs;+ color: $text-primary;+ }+ }++ &__actions {+ display: flex;+ flex-wrap: wrap;+ justify-content: center;+ gap: $space-2;+ margin-top: $space-5;+ }++ &__note {+ display: inline-flex;+ align-items: center;+ gap: 6px;+ max-width: 46ch;+ margin: $space-5 0 0;+ font-family: $font-mono;+ font-size: $font-size-xs;+ color: $text-tertiary;+ svg { flex-shrink: 0; }+ }+ }+// ─── Context menu ─────────────────────────────────────.dbx-context {position: fixed;@@ -1002,6 +1141,549 @@ $dbx-sqlite: #3d8fd1;}}+// ============================================+// ENGINE CATALOG & INSTALL (drawer + modal chrome)+//+// Everything below renders inside a Radix portal — a drawer or a modal is NOT a+// descendant of `.db-explorer`, so these rules must live at the top level or+// they simply never reach the markup. Same `dbx-` namespace, different host.+// ============================================++// The portalled half of the spinner: @keyframes bubble to the top level, the+// class that uses them does not.+.dbx-spin { animation: dbx-spin 1s linear infinite; }++.dbx-drawer {+ // Three stacked regions inside the sheet body — filters, scroller, footer —+ // so the footer stays put while the catalog scrolls under it.+ &__shell {+ display: flex;+ flex-direction: column;+ height: 100%;+ min-height: 0;+ }++ &__scroll {+ flex: 1;+ min-height: 0;+ overflow-y: auto;+ padding: $space-4 $space-5 $space-6;+ }++ &__lead {+ margin: 0 0 $space-4;+ color: $text-tertiary;+ font-size: $font-size-sm;+ line-height: 1.55;+ }++ &__foot {+ display: flex;+ align-items: center;+ gap: $space-2;+ flex-shrink: 0;+ padding: $space-3 $space-5;+ border-top: 1px solid $border-subtle;+ background: $bg-elevated;++ .btn:first-child { margin-right: auto; }+ &--split { justify-content: space-between; }+ }++ &__footnote {+ color: $text-tertiary;+ font-size: $font-size-xs;+ line-height: 1.5;+ }++ // A drawer is not inside a page form, so its bare controls have no styling+ // to inherit — give them the panel's own instead of the browser's.+ select {+ width: 100%;+ padding: 8px 11px;+ background: $bg-elevated;+ border: 1px solid $border-default;+ border-radius: $radius-md;+ color: $text-primary;+ font-family: inherit;+ font-size: $font-size-sm;+ cursor: pointer;++ &:focus {+ outline: none;+ border-color: $accent-primary;+ box-shadow: 0 0 0 3px $accent-glow;+ }+ }+}++// ─── Fields ───────────────────────────────────────────────+.dbx-field {+ margin-bottom: $space-4;+ &:last-child { margin-bottom: 0; }++ &__label {+ display: block;+ margin-bottom: 7px;+ color: $text-secondary;+ font-size: $font-size-xs;+ font-weight: $font-weight-medium;+ }++ &__optional { color: $text-tertiary; font-weight: $font-weight-normal; }+}++.dbx-field-row {+ display: grid;+ grid-template-columns: 1fr 1fr;+ gap: $space-3;+ align-items: start;+}++.dbx-field-hint {+ margin: 6px 0 0;+ color: $text-tertiary;+ font-size: $font-size-xs;+ line-height: 1.5;++ code {+ padding: 1px 5px;+ border-radius: $radius-sm;+ background: $bg-tertiary;+ font-family: $font-mono;+ color: $text-secondary;+ }+}++.dbx-input {+ display: flex;+ align-items: center;+ gap: 9px;+ padding: 8px 11px;+ background: $bg-elevated;+ border: 1px solid $border-default;+ border-radius: $radius-md;+ transition: border-color $transition-fast, box-shadow $transition-fast;++ &:focus-within {+ border-color: $accent-primary;+ box-shadow: 0 0 0 3px $accent-glow;+ }++ > svg { flex-shrink: 0; color: $text-tertiary; }++ input {+ flex: 1;+ min-width: 0;+ background: none;+ border: none;+ outline: none;+ color: $text-primary;+ font-size: $font-size-sm;+ &::placeholder { color: $text-tertiary; }+ }+}++.dbx-inline-link {+ display: inline-flex;+ align-items: center;+ gap: 5px;+ padding: 0;+ background: none;+ border: none;+ color: $accent-primary;+ font-size: $font-size-sm;+ text-decoration: none;+ cursor: pointer;++ &:hover:not(:disabled) { text-decoration: underline; }+ &:disabled { opacity: 0.6; cursor: default; }+ svg { flex-shrink: 0; }+}++// ─── Key / value facts ────────────────────────────────────+.dbx-kv {+ margin: 0;+ border: 1px solid $border-default;+ border-radius: $radius-md;+ overflow: hidden;++ &__row {+ display: flex;+ align-items: center;+ justify-content: space-between;+ gap: $space-3;+ padding: 9px 13px;+ border-top: 1px solid $border-subtle;+ &:first-child { border-top: none; }++ dt, .dbx-kv__key {+ display: inline-flex;+ align-items: center;+ gap: 6px;+ margin: 0;+ flex-shrink: 0;+ color: $text-tertiary;+ font-size: $font-size-xs;+ svg { color: $text-tertiary; }+ }++ dd {+ margin: 0;+ min-width: 0;+ color: $text-primary;+ font-size: $font-size-sm;+ text-align: right;+ }+ }++ &__mono {+ font-family: $font-mono;+ font-size: $font-size-xs;+ word-break: break-all;+ }++ &__ok { color: $success; }+}++// The password is the one thing on the panel you cannot recover later, so it+// gets reveal, regenerate and copy in the same row as the dots.+.dbx-secret {+ display: flex;+ align-items: center;+ justify-content: flex-end;+ gap: 6px;++ &__value {+ font-family: $font-mono;+ font-size: $font-size-xs;+ letter-spacing: 0.06em;+ color: $text-primary;+ word-break: break-all;+ }++ &__actions { display: inline-flex; gap: 2px; flex-shrink: 0; }+}++.dbx-icon-xs {+ display: grid;+ place-items: center;+ width: 24px;+ height: 24px;+ padding: 0;+ background: transparent;+ border: none;+ border-radius: $radius-sm;+ color: $text-tertiary;+ cursor: pointer;+ flex-shrink: 0;+ transition: background $transition-fast, color $transition-fast;++ &:hover:not(:disabled) { background: $bg-tertiary; color: $text-primary; }+ &:disabled { opacity: 0.45; cursor: not-allowed; }+}++// ─── Option rows + the public-port warning ────────────────+.dbx-optlist {+ border: 1px solid $border-default;+ border-radius: $radius-md;+ overflow: hidden;++ > * + * { border-top: 1px solid $border-subtle; }+}++.dbx-opt-row {+ display: flex;+ align-items: center;+ justify-content: space-between;+ gap: $space-4;+ padding: 11px 13px;++ &__text { display: flex; flex-direction: column; gap: 2px; min-width: 0; }+ &__title { color: $text-primary; font-size: $font-size-sm; font-weight: $font-weight-medium; }+ &__sub { color: $text-tertiary; font-size: $font-size-xs; line-height: 1.45; }+}++// Not decorative. A public database port is the single most consequential thing+// this drawer can do, so it is called out in warning colour every time.+.dbx-warn-line {+ display: flex;+ align-items: flex-start;+ gap: $space-2;+ margin: $space-3 0 0;+ padding: 10px 12px;+ background: $warning-bg;+ border: 1px solid $warning-border;+ border-radius: $radius-md;+ color: $text-secondary;+ font-size: $font-size-xs;+ line-height: 1.55;++ svg { flex-shrink: 0; margin-top: 1px; color: $warning; }+}++.dbx-result-lead {+ display: flex;+ align-items: flex-start;+ gap: $space-2;+ margin-bottom: $space-4;+ padding: 11px 13px;+ background: $success-bg;+ border: 1px solid $success-border;+ border-radius: $radius-md;+ color: $text-secondary;+ font-size: $font-size-sm;+ line-height: 1.55;++ svg { flex-shrink: 0; margin-top: 2px; color: $success; }+}++// ─── Catalog: filters, rows, cards ────────────────────────+.dbx-eng-filters {+ display: flex;+ flex-direction: column;+ gap: $space-2;+ flex-shrink: 0;+ padding: $space-3 $space-5;+ background: $bg-elevated;+ border-bottom: 1px solid $border-subtle;+}++.dbx-eng-search { flex: 1 1 auto; width: 100%; }++.dbx-cat-chips { display: flex; flex-wrap: wrap; gap: 6px; }++.dbx-cat-chip {+ padding: 3px 10px;+ background: $bg-tertiary;+ border: 1px solid transparent;+ border-radius: $radius-full;+ color: $text-secondary;+ font-size: $font-size-xs;+ cursor: pointer;+ transition: background $transition-fast, color $transition-fast, border-color $transition-fast;++ &:hover { color: $text-primary; }+ &.is-on {+ background: $accent-glow;+ border-color: $accent-primary;+ color: $accent-primary;+ }+}++.dbx-eng-section { margin-bottom: $space-6; &:last-child { margin-bottom: 0; } }++.dbx-eyebrow {+ margin: 0 0 $space-2;+ color: $text-tertiary;+ font-size: 10.5px;+ font-weight: $font-weight-semibold;+ letter-spacing: 0.06em;+ text-transform: uppercase;+}++.dbx-eng-glyph {+ display: grid;+ place-items: center;+ width: 24px;+ height: 24px;+ flex-shrink: 0;+ color: $text-secondary;++ &--lg {+ width: 38px;+ height: 38px;+ background: $bg-tertiary;+ border-radius: $radius-md;+ }+}++.dbx-eng-img { object-fit: contain; border-radius: 3px; }++.dbx-eng-rowtext { display: flex; flex-direction: column; gap: 2px; min-width: 0; flex: 1; }++.dbx-eng-name {+ color: $text-primary;+ font-size: $font-size-sm;+ font-weight: $font-weight-medium;+ @include dbx-trunc;+}++.dbx-eng-sub {+ color: $text-tertiary;+ font-family: $font-mono;+ font-size: 11px;+ @include dbx-trunc;+}++.dbx-eng-family {+ flex-shrink: 0;+ color: $text-tertiary;+ font-family: $font-mono;+ font-size: 10px;+ letter-spacing: 0.04em;+ text-transform: uppercase;+}++.dbx-eng-facts {+ min-width: 0;+ color: $text-tertiary;+ font-family: $font-mono;+ font-size: 11px;+ @include dbx-trunc;+}++.dbx-eng-badge {+ display: inline-flex;+ align-items: center;+ gap: 5px;+ flex-shrink: 0;+ padding: 3px 8px;+ border-radius: $radius-sm;+ font-family: $font-mono;+ font-size: 10.5px;++ &.is-running { color: $success; background: $success-bg; }+ &.is-installing { color: $warning; background: $warning-bg; }+ &.is-failed { color: $danger; background: $danger-bg; }+ &.is-stopped { color: $text-tertiary; background: $bg-tertiary; }+}++.dbx-eng-list {+ list-style: none;+ margin: 0;+ padding: 0;+ border: 1px solid $border-default;+ border-radius: $radius-md;+ overflow: hidden;+}++.dbx-eng-row {+ display: flex;+ align-items: center;+ gap: $space-3;+ padding: 11px 13px;+ border-top: 1px solid $border-subtle;+ &:first-child { border-top: none; }+}++.dbx-engine-grid {+ display: grid;+ grid-template-columns: repeat(auto-fill, minmax(228px, 1fr));+ gap: $space-3;+ list-style: none;+ margin: 0;+ padding: 0;+}++.dbx-engine-card {+ display: flex;++ // The whole card is the hit target — a card you can only activate by its+ // small "Install" label is a card that reads as clickable and isn't.+ &__hit {+ display: flex;+ flex-direction: column;+ gap: 9px;+ width: 100%;+ min-height: 168px;+ padding: $space-3;+ background: $bg-elevated;+ border: 1px solid $border-default;+ border-radius: $radius-md;+ text-align: left;+ cursor: pointer;+ transition: border-color $transition-fast, background $transition-fast, transform $transition-fast;++ &:hover {+ border-color: $accent-primary;+ background: $bg-hover;+ transform: translateY(-1px);+ }+ &:focus-visible { outline: 2px solid $accent-primary; outline-offset: 2px; }+ }++ &__top { display: flex; align-items: flex-start; gap: $space-2; }++ &__desc {+ flex: 1;+ color: $text-tertiary;+ font-size: $font-size-xs;+ line-height: 1.5;+ }++ &__foot {+ display: flex;+ align-items: center;+ justify-content: space-between;+ gap: $space-2;+ }++ &__cta {+ display: inline-flex;+ align-items: center;+ gap: 5px;+ flex-shrink: 0;+ padding: 3px 10px;+ background: $accent-primary;+ border-radius: $radius-sm;+ color: #fff;+ font-size: $font-size-xs;+ font-weight: $font-weight-semibold;+ }+}++// ─── Engine picker (create-database modal) ────────────────+.dbx-eng-pick {+ display: grid;+ grid-template-columns: repeat(auto-fill, minmax(158px, 1fr));+ gap: $space-2;+}++.dbx-eng-opt {+ display: flex;+ align-items: center;+ gap: 9px;+ min-width: 0;+ padding: 9px 11px;+ background: $bg-elevated;+ border: 1px solid $border-default;+ border-radius: $radius-md;+ text-align: left;+ cursor: pointer;+ transition: border-color $transition-fast, background $transition-fast;++ &:hover:not(:disabled) { border-color: $border-active; background: $bg-hover; }+ &.is-on { border-color: $accent-primary; background: $accent-glow; }+ &:disabled { opacity: 0.5; cursor: not-allowed; }+ &--ghost { border-style: dashed; color: $text-tertiary; }++ &__ico {+ display: grid;+ place-items: center;+ width: 22px;+ flex-shrink: 0;+ color: $text-secondary;++ &.is-mysql { color: $color-mysql; }+ &.is-postgresql { color: $color-postgresql; }+ }++ &__text { display: flex; flex-direction: column; gap: 1px; min-width: 0; }+ &__name {+ color: $text-primary;+ font-size: $font-size-sm;+ font-weight: $font-weight-medium;+ @include dbx-trunc;+ }+ &__sub { color: $text-tertiary; font-family: $font-mono; font-size: 10.5px; }+}++@media (prefers-reduced-motion: reduce) {+ .dbx-spin { animation: none; }+ .dbx-engine-card__hit:hover { transform: none; }+}+// ============================================// MANAGED DATABASES (modal panel)// ============================================