Skip to content

ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.

feat(databases): install any engine, because an engine is just a template

Juan Denis3070353631d1
diff --git a/backend/app/__init__.py b/backend/app/__init__.py
index 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_bp
app.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 SSO
from app.api.managed_db_users import managed_db_users_bp
app.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.py
index 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) volumes
result = 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_data
except Exception as e:
cleanup_results['docker'] = {'error': str(e)}
diff --git a/backend/app/api/database_engines.py b/backend/app/api/database_engines.py
new file mode 100644
index 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 202
diff --git a/backend/app/api/templates.py b/backend/app/api/templates.py
index 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), 200
diff --git a/backend/app/services/database_engine_service.py b/backend/app/services/database_engine_service.py
new file mode 100644
index 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.py
index 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 version
SCHEMA_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'
+
@classmethod
def 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],
+ }
+
@classmethod
def 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 random
return 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
+
@classmethod
def _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'] = engine
templates.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)]
+
@classmethod
def 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``. Lets
Prompture 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.yaml
new file mode 100644
index 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: 20GB
diff --git a/backend/templates/cockroachdb.yaml b/backend/templates/cockroachdb.yaml
new file mode 100644
index 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: 10GB
diff --git a/backend/templates/couchdb.yaml b/backend/templates/couchdb.yaml
new file mode 100644
index 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: 5GB
diff --git a/backend/templates/index.json b/backend/templates/index.json
index 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 file
diff --git a/backend/templates/influxdb.yaml b/backend/templates/influxdb.yaml
new file mode 100644
index 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: 10GB
diff --git a/backend/templates/mariadb.yaml b/backend/templates/mariadb.yaml
new file mode 100644
index 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: 5GB
diff --git a/backend/templates/meilisearch.yaml b/backend/templates/meilisearch.yaml
index 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 API
type: port
default: "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.1
hidden: true
- name: MASTER_KEY
description: 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-stopped
ports:
- - "${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.yaml
new file mode 100644
index 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: 10GB
diff --git a/backend/templates/mysql.yaml b/backend/templates/mysql.yaml
new file mode 100644
index 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: 5GB
diff --git a/backend/templates/neo4j.yaml b/backend/templates/neo4j.yaml
new file mode 100644
index 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: 10GB
diff --git a/backend/templates/postgresql.yaml b/backend/templates/postgresql.yaml
new file mode 100644
index 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: 5GB
diff --git a/backend/templates/redis.yaml b/backend/templates/redis.yaml
new file mode 100644
index 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: 1GB
diff --git a/backend/templates/valkey.yaml b/backend/templates/valkey.yaml
new file mode 100644
index 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: 1GB
diff --git a/backend/tests/test_database_engines.py b/backend/tests/test_database_engines.py
new file mode 100644
index 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.py
index 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 the
repo-sync flow) must enumerate every template currently on disk."""
diff --git a/frontend/src/components/databases/DbBlankStates.jsx b/frontend/src/components/databases/DbBlankStates.jsx
new file mode 100644
index 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.jsx
new file mode 100644
index 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.jsx
new file mode 100644
index 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.jsx
new file mode 100644
index 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&apos;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&apos;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.jsx
index 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>
+ )}
+
<button
type="button"
className="dbx-tree-more"
diff --git a/frontend/src/components/databases/engineHelpers.js b/frontend/src/components/databases/engineHelpers.js
new file mode 100644
index 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.jsx
index 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 (
<CredentialsResult
title="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.jsx
index 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-deps
return (
@@ -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">
<EmptyState
icon={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' && (
<ConsoleTab
conn={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.js
index 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.scss
index 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)
// ============================================