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(sites): wildcard HTTPS for managed subdomains

Juan Denis0a74e5670d2f
diff --git a/backend/app/api/admin.py b/backend/app/api/admin.py
index bc8b6b2b..143eeb2d 100644
--- a/backend/app/api/admin.py
+++ b/backend/app/api/admin.py
@@ -359,6 +359,28 @@ def update_setting(key):
}), 200
+# ============================================
+# Managed-sites domain & HTTPS (Phase 5)
+# ============================================
+
+@admin_bp.route('/sites-https/status', methods=['GET'])
+@admin_required
+def sites_https_status():
+ """Report managed-sites base domain, server IP, providers, and HTTPS state."""
+ from app.services.sites_https_service import SitesHttpsService
+ return jsonify(SitesHttpsService.status()), 200
+
+
+@admin_bp.route('/sites-https/setup', methods=['POST'])
+@admin_required
+def sites_https_setup():
+ """Create the wildcard DNS record + issue the wildcard cert for the base domain."""
+ from app.services.sites_https_service import SitesHttpsService
+ data = request.get_json() or {}
+ result = SitesHttpsService.setup(data.get('provider_id'), email=data.get('email'))
+ return jsonify(result), 200 if result.get('success') else 400
+
+
# ============================================
# Admin Statistics Endpoints
# ============================================
diff --git a/backend/app/services/advanced_ssl_service.py b/backend/app/services/advanced_ssl_service.py
index 5a0de41d..f418a03d 100644
--- a/backend/app/services/advanced_ssl_service.py
+++ b/backend/app/services/advanced_ssl_service.py
@@ -36,23 +36,50 @@ class AdvancedSSLService:
return AdvancedSSLService.SSL_PROFILES
@staticmethod
- def issue_wildcard_cert(domain, dns_provider, credentials):
- """Issue wildcard SSL via DNS-01 challenge."""
+ def issue_wildcard_cert(domain, dns_provider, credentials, email=None):
+ """Issue a wildcard cert (domain + *.domain) via Let's Encrypt DNS-01.
+
+ Supports cloudflare (API token) and route53 (AWS key/secret). The certbot
+ DNS plugin matching the system certbot is installed best-effort first.
+ Returns the on-disk cert/key paths on success.
+ """
+ import os
+ from app.utils.system import PackageManager
+
wildcard = f'*.{domain}'
cmd = ['certbot', 'certonly', '--non-interactive', '--agree-tos',
'--dns-' + dns_provider, '-d', domain, '-d', wildcard]
+ cmd.extend(['--email', email] if email else ['--register-unsafely-without-email'])
+ # Best-effort: ensure the DNS plugin matching the system certbot exists.
+ if PackageManager.is_available():
+ try:
+ PackageManager.install([f'python3-certbot-dns-{dns_provider}'], timeout=300)
+ except Exception:
+ pass # certbot reports a clear error below if the plugin is truly missing
+
+ run_kwargs = {}
if dns_provider == 'cloudflare':
cred_file = f'/tmp/certbot-{dns_provider}.ini'
with open(cred_file, 'w') as f:
f.write(f"dns_cloudflare_api_token = {credentials.get('api_token', '')}\n")
- import os
os.chmod(cred_file, 0o600)
cmd.extend(['--dns-cloudflare-credentials', cred_file])
+ elif dns_provider == 'route53':
+ run_kwargs['env'] = {
+ **os.environ,
+ 'AWS_ACCESS_KEY_ID': credentials.get('api_key', ''),
+ 'AWS_SECRET_ACCESS_KEY': credentials.get('api_secret', ''),
+ }
try:
- result = run_command(cmd)
- return {'success': True, 'domain': domain, 'type': 'wildcard', 'output': result.get('stdout', '')}
+ result = run_command(cmd, **run_kwargs)
+ return {
+ 'success': True, 'domain': domain, 'type': 'wildcard',
+ 'certificate_path': f'/etc/letsencrypt/live/{domain}/fullchain.pem',
+ 'private_key_path': f'/etc/letsencrypt/live/{domain}/privkey.pem',
+ 'output': result.get('stdout', ''),
+ }
except Exception as e:
return {'success': False, 'error': str(e)}
diff --git a/backend/app/services/nginx_service.py b/backend/app/services/nginx_service.py
index 3d2d693e..f0f6439b 100644
--- a/backend/app/services/nginx_service.py
+++ b/backend/app/services/nginx_service.py
@@ -389,8 +389,14 @@ location /p/ {{
@classmethod
def create_site(cls, name: str, app_type: str, domains: List[str],
- root_path: str, port: int = None, php_version: str = '8.2') -> Dict:
- """Create a new site configuration."""
+ root_path: str, port: int = None, php_version: str = '8.2',
+ ssl_cert: str = None, ssl_key: str = None) -> Dict:
+ """Create a new site configuration.
+
+ When ``ssl_cert``/``ssl_key`` are given the generated vhost serves HTTPS
+ (443) from that cert with an HTTP->HTTPS redirect — used to point managed
+ subdomains at the base-domain wildcard cert.
+ """
if not domains:
return {'success': False, 'error': 'At least one domain is required'}
@@ -441,6 +447,9 @@ location /p/ {{
else:
return {'success': False, 'error': f'Unknown app type: {app_type}'}
+ if ssl_cert and ssl_key:
+ config = cls._with_ssl(config, domains_str, ssl_cert, ssl_key)
+
# Write config file
config_path = os.path.join(cls.SITES_AVAILABLE, name)
try:
@@ -456,6 +465,20 @@ location /p/ {{
except Exception as e:
return {'success': False, 'error': str(e)}
+ @classmethod
+ def _with_ssl(cls, http_config: str, domains: str, ssl_cert: str, ssl_key: str) -> str:
+ """Turn an HTTP server block into HTTPS: swap the :80 listens for the TLS
+ block (so the existing server serves 443) and prepend an HTTP->HTTPS
+ redirect. Idempotent because create_site regenerates the whole file."""
+ ssl_block = cls.SSL_BLOCK.format(ssl_cert=ssl_cert, ssl_key=ssl_key)
+ https_config = http_config.replace(
+ ' listen 80;\n listen [::]:80;',
+ ssl_block.strip('\n'),
+ 1,
+ )
+ redirect = cls.SSL_REDIRECT_TEMPLATE.format(domains=domains)
+ return redirect + '\n' + https_config
+
@classmethod
def enable_site(cls, name: str) -> Dict:
"""Enable a site by creating symlink in sites-enabled."""
diff --git a/backend/app/services/settings_service.py b/backend/app/services/settings_service.py
index 8e47adf2..e33a48cc 100644
--- a/backend/app/services/settings_service.py
+++ b/backend/app/services/settings_service.py
@@ -43,6 +43,24 @@ class SettingsService:
'type': 'integer',
'description': 'Starting host port when auto-assigning ports to managed apps/sites (0 = use each template\'s own default). The scanner still skips ports already in use.'
},
+ # Managed-site routing & HTTPS (Phases 1/3/5). Base domain + server IP
+ # drive subdomain publishing and auto-DNS; sites_https_enabled is set by
+ # the wildcard-HTTPS setup, after which managed subdomains serve TLS.
+ 'sites_base_domain': {
+ 'value': '',
+ 'type': 'string',
+ 'description': 'Base domain for managed sites — each is published at <slug>.<base_domain>. Point a wildcard DNS record (*.<base_domain>) at this server.'
+ },
+ 'server_public_ip': {
+ 'value': '',
+ 'type': 'string',
+ 'description': 'Public IP of this server, used to auto-create DNS A records for managed domains.'
+ },
+ 'sites_https_enabled': {
+ 'value': False,
+ 'type': 'boolean',
+ 'description': 'Whether the wildcard certificate for the sites base domain is set up; managed subdomains serve HTTPS when true.'
+ },
# SSO / OAuth settings
'sso_google_enabled': {'value': False, 'type': 'boolean', 'description': 'Enable Google OAuth login'},
'sso_google_client_id': {'value': '', 'type': 'string', 'description': 'Google OAuth client ID'},
diff --git a/backend/app/services/site_domain_service.py b/backend/app/services/site_domain_service.py
index 02075d6b..10f9ea06 100644
--- a/backend/app/services/site_domain_service.py
+++ b/backend/app/services/site_domain_service.py
@@ -40,6 +40,31 @@ class SiteDomainService:
"""Public IP that wildcard/custom A-records should point at (Phase 3)."""
return SystemSettings.get('server_public_ip') or current_app.config.get('SERVER_PUBLIC_IP') or None
+ @classmethod
+ def https_enabled(cls):
+ """True once the wildcard certificate for the base domain is set up, so
+ managed subdomains should be served over HTTPS (Phase 5)."""
+ return bool(SystemSettings.get('sites_https_enabled', False))
+
+ @classmethod
+ def wildcard_cert_paths(cls):
+ """(fullchain, privkey) paths for the base domain's wildcard cert, or
+ (None, None) when no base domain is configured."""
+ base = cls.base_domain()
+ if not base:
+ return (None, None)
+ return (f'/etc/letsencrypt/live/{base}/fullchain.pem',
+ f'/etc/letsencrypt/live/{base}/privkey.pem')
+
+ @classmethod
+ def covers(cls, host):
+ """Whether the base domain's wildcard cert covers ``host`` — i.e. host is
+ the base domain or a direct subdomain of it."""
+ base = cls.base_domain()
+ if not base or not host:
+ return False
+ return host == base or host.endswith('.' + base)
+
@staticmethod
def slugify(name):
"""Turn a site name into a DNS-safe label (a-z, 0-9, single dashes)."""
diff --git a/backend/app/services/sites_https_service.py b/backend/app/services/sites_https_service.py
new file mode 100644
index 00000000..045cb4ed
--- /dev/null
+++ b/backend/app/services/sites_https_service.py
@@ -0,0 +1,68 @@
+"""One-time setup that makes managed subdomains HTTPS.
+
+Creates the wildcard DNS record (``*.<base_domain>``) via a connected provider
+and issues a wildcard Let's Encrypt certificate over DNS-01 reusing that
+provider's credentials. Once the cert exists, ``sites_https_enabled`` flips on
+and managed subdomain vhosts serve TLS from it (see SiteDomainService and
+NginxService.create_site's ssl args).
+"""
+from app.models.email import DNSProviderConfig
+from app.services.advanced_ssl_service import AdvancedSSLService
+from app.services.dns_provider_service import DNSProviderService
+from app.services.settings_service import SettingsService
+from app.services.site_domain_service import SiteDomainService
+
+
+class SitesHttpsService:
+
+ @classmethod
+ def status(cls):
+ """Current managed-sites routing/HTTPS configuration."""
+ return {
+ 'base_domain': SiteDomainService.base_domain(),
+ 'server_ip': SiteDomainService.server_ip(),
+ 'https_enabled': SiteDomainService.https_enabled(),
+ 'providers': DNSProviderService.list_providers(),
+ }
+
+ @classmethod
+ def setup(cls, provider_id, email=None):
+ """Create ``*.<base>`` + ``<base>`` A records and issue the wildcard cert.
+
+ Requires a configured base domain and a connected DNS provider. The
+ server IP is needed to create the A records; without it the cert can
+ still be issued (DNS-01 doesn't need them) but traffic won't route until
+ the records exist — surfaced as a warning rather than a failure.
+ """
+ base = SiteDomainService.base_domain()
+ if not base:
+ return {'success': False, 'error': 'Set the sites base domain first (Settings).'}
+
+ config = DNSProviderConfig.query.get(provider_id) if provider_id else None
+ if not config:
+ return {'success': False, 'error': 'A connected DNS provider is required to issue the wildcard certificate.'}
+
+ warnings = []
+ ip = SiteDomainService.server_ip()
+ dns = {}
+ if ip:
+ dns['wildcard'] = DNSProviderService.ensure_a_record(f'*.{base}', ip)
+ dns['apex'] = DNSProviderService.ensure_a_record(base, ip)
+ for r in dns.values():
+ if not r.get('created'):
+ warnings.append(r.get('message') or 'A record not created.')
+ else:
+ warnings.append(f'No server public IP set — add the *.{base} and {base} A records manually (or set the IP in Settings).')
+
+ creds = ({'api_token': config.api_key} if config.provider == 'cloudflare'
+ else {'api_key': config.api_key, 'api_secret': config.api_secret})
+ cert = AdvancedSSLService.issue_wildcard_cert(base, config.provider, creds, email=email)
+ if not cert.get('success'):
+ return {'success': False, 'error': f"Wildcard certificate failed: {cert.get('error')}",
+ 'dns': dns, 'ssl': cert, 'warning': '; '.join(warnings) if warnings else None}
+
+ SettingsService.set('sites_https_enabled', True)
+
+ return {'success': True, 'base_domain': base, 'https_enabled': True,
+ 'dns': dns, 'ssl': cert, 'cert_path': cert.get('certificate_path'),
+ 'warning': '; '.join(warnings) if warnings else None}
diff --git a/backend/app/services/wordpress_service.py b/backend/app/services/wordpress_service.py
index c46627ba..03db2406 100644
--- a/backend/app/services/wordpress_service.py
+++ b/backend/app/services/wordpress_service.py
@@ -1744,7 +1744,7 @@ RewriteRule ^wp-content/uploads/.*\\.php$ - [F]
# (e.g. an unconfigured production install).
site_host = SiteDomainService.subdomain_for(safe_name)
if site_host:
- site_url = SiteDomainService.site_url(site_host)
+ site_url = SiteDomainService.site_url(site_host, ssl=SiteDomainService.https_enabled())
else:
site_url = f'http://localhost:{http_port}' if http_port else 'http://localhost'
wp_warning = None
@@ -1892,16 +1892,23 @@ RewriteRule ^wp-content/uploads/.*\\.php$ - [F]
raises; returns ``{'nginx', 'warning'}``."""
from app.models.domain import Domain
from app.services.nginx_service import NginxService
+ from app.services.site_domain_service import SiteDomainService
if not app.port:
return {'nginx': None, 'warning': None}
domains = [d.name for d in Domain.query.filter_by(application_id=app.id).all()]
if not domains:
return {'nginx': None, 'warning': None}
+ # Serve the wildcard cert when HTTPS is set up and every vhost domain is a
+ # managed subdomain it covers (custom domains carry their own cert).
+ ssl_cert = ssl_key = None
+ if SiteDomainService.https_enabled() and all(SiteDomainService.covers(d) for d in domains):
+ ssl_cert, ssl_key = SiteDomainService.wildcard_cert_paths()
try:
res = NginxService.create_site(
name=app.name, app_type='docker', domains=domains,
root_path=app.root_path or '', port=app.port,
+ ssl_cert=ssl_cert, ssl_key=ssl_key,
)
if res.get('success'):
en = NginxService.enable_site(app.name)
diff --git a/backend/tests/test_sites_https.py b/backend/tests/test_sites_https.py
new file mode 100644
index 00000000..07e5b5ac
--- /dev/null
+++ b/backend/tests/test_sites_https.py
@@ -0,0 +1,229 @@
+"""Phase 5 proving tests — wildcard HTTPS for managed subdomains.
+
+A one-time setup creates the *.<base> + <base> A records via a connected DNS
+provider and issues a wildcard cert, after which managed subdomain vhosts serve
+TLS from it.
+"""
+
+
+def _mk_user(db, username='owner'):
+ from app.models import User
+ from werkzeug.security import generate_password_hash
+ u = User(email=f'{username}@test.local', username=username,
+ password_hash=generate_password_hash('x'),
+ role=User.ROLE_ADMIN, is_active=True)
+ db.session.add(u)
+ db.session.commit()
+ return u
+
+
+def _mk_app(db, user_id, name='blog', port=8300, host='blog.lvh.me'):
+ from app.models import Application
+ from app.models.domain import Domain
+ a = Application(name=name, app_type='docker', user_id=user_id, root_path=f'/srv/{name}', port=port)
+ db.session.add(a)
+ db.session.commit()
+ db.session.add(Domain(name=host, is_primary=True, application_id=a.id))
+ db.session.commit()
+ return a
+
+
+def _mk_provider(db, provider='cloudflare'):
+ from app.models.email import DNSProviderConfig
+ c = DNSProviderConfig(name='cf', provider=provider, api_key='tok', api_secret='sec')
+ db.session.add(c)
+ db.session.commit()
+ return c
+
+
+# ── SiteDomainService HTTPS helpers ─────────────────────────────────────────
+
+def test_https_helpers(app):
+ from app import db
+ from app.models.system_settings import SystemSettings
+ from app.services.site_domain_service import SiteDomainService
+
+ assert SiteDomainService.https_enabled() is False
+ # Testing base domain is lvh.me.
+ assert SiteDomainService.covers('blog.lvh.me') is True
+ assert SiteDomainService.covers('lvh.me') is True
+ assert SiteDomainService.covers('other.com') is False
+ fc, key = SiteDomainService.wildcard_cert_paths()
+ assert fc == '/etc/letsencrypt/live/lvh.me/fullchain.pem'
+ assert key == '/etc/letsencrypt/live/lvh.me/privkey.pem'
+
+ SystemSettings.set('sites_https_enabled', True, value_type='boolean')
+ db.session.commit()
+ assert SiteDomainService.https_enabled() is True
+
+
+# ── nginx SSL config generation (pure) ──────────────────────────────────────
+
+def test_with_ssl_builds_redirect_and_443():
+ from app.services.nginx_service import NginxService
+ http = NginxService.DOCKER_SITE_TEMPLATE.format(name='blog', domains='blog.lvh.me', port=8300)
+ out = NginxService._with_ssl(http, 'blog.lvh.me', '/c/fullchain.pem', '/c/privkey.pem')
+ assert 'return 301 https://$server_name$request_uri;' in out # HTTP->HTTPS redirect
+ assert 'listen 443 ssl http2;' in out # app block now on 443
+ assert 'ssl_certificate /c/fullchain.pem;' in out
+ assert 'ssl_certificate_key /c/privkey.pem;' in out
+ assert 'proxy_pass http://127.0.0.1:8300;' in out # proxy preserved
+ assert out.count('listen 80;') == 1 # only the redirect block on :80
+
+
+# ── issue_wildcard_cert command construction ────────────────────────────────
+
+def test_issue_wildcard_cert_route53(monkeypatch):
+ import app.services.advanced_ssl_service as mod
+ from app.utils.system import PackageManager
+ from app.services.advanced_ssl_service import AdvancedSSLService
+
+ monkeypatch.setattr(PackageManager, 'is_available', staticmethod(lambda: False))
+ captured = {}
+
+ def fake_run(cmd, **kw):
+ captured['cmd'] = list(cmd)
+ captured['kw'] = kw
+ return {'stdout': 'Congratulations'}
+
+ monkeypatch.setattr(mod, 'run_command', fake_run)
+
+ res = AdvancedSSLService.issue_wildcard_cert('example.com', 'route53',
+ {'api_key': 'AK', 'api_secret': 'SK'},
+ assert res['success'] is True
+ assert res['certificate_path'] == '/etc/letsencrypt/live/example.com/fullchain.pem'
+ cmd = captured['cmd']
+ assert '--dns-route53' in cmd
+ assert 'example.com' in cmd and '*.example.com' in cmd
+ assert '--email' in cmd and '[email protected]' in cmd
+ assert captured['kw']['env']['AWS_ACCESS_KEY_ID'] == 'AK'
+ assert captured['kw']['env']['AWS_SECRET_ACCESS_KEY'] == 'SK'
+
+
+# ── setup orchestration ─────────────────────────────────────────────────────
+
+def test_setup_creates_records_issues_cert_persists(app, monkeypatch):
+ from app import db
+ from app.models.system_settings import SystemSettings
+ from app.services.dns_provider_service import DNSProviderService
+ from app.services.advanced_ssl_service import AdvancedSSLService
+ from app.services.sites_https_service import SitesHttpsService
+ from app.services.site_domain_service import SiteDomainService
+
+ provider = _mk_provider(db)
+ SystemSettings.set('server_public_ip', '203.0.113.9', value_type='string')
+ db.session.commit()
+
+ created = []
+ monkeypatch.setattr(DNSProviderService, 'ensure_a_record',
+ classmethod(lambda cls, host, ip: (created.append(host),
+ {'created': True, 'record': {'name': host, 'value': ip}})[1]))
+ cert_calls = {}
+
+ def fake_cert(domain, provider_name, creds, email=None):
+ cert_calls.update({'domain': domain, 'provider': provider_name, 'creds': creds, 'email': email})
+ return {'success': True, 'certificate_path': f'/etc/letsencrypt/live/{domain}/fullchain.pem'}
+
+ monkeypatch.setattr(AdvancedSSLService, 'issue_wildcard_cert', staticmethod(fake_cert))
+
+ res = SitesHttpsService.setup(provider.id, email='[email protected]')
+ assert res['success'] is True
+ assert res['https_enabled'] is True
+ assert set(created) == {'*.lvh.me', 'lvh.me'} # wildcard + apex
+ assert cert_calls['domain'] == 'lvh.me'
+ assert cert_calls['provider'] == 'cloudflare'
+ assert cert_calls['creds'] == {'api_token': 'tok'} # reuses the connected provider's token
+ assert cert_calls['email'] == '[email protected]'
+ assert SiteDomainService.https_enabled() is True # persisted
+
+
+def test_setup_requires_provider(app):
+ from app.services.sites_https_service import SitesHttpsService
+ res = SitesHttpsService.setup(None)
+ assert res['success'] is False
+ assert 'provider' in res['error'].lower()
+
+
+def test_setup_cert_failure_does_not_enable_https(app, monkeypatch):
+ from app import db
+ from app.models.system_settings import SystemSettings
+ from app.services.dns_provider_service import DNSProviderService
+ from app.services.advanced_ssl_service import AdvancedSSLService
+ from app.services.sites_https_service import SitesHttpsService
+ from app.services.site_domain_service import SiteDomainService
+
+ provider = _mk_provider(db)
+ SystemSettings.set('server_public_ip', '1.2.3.4', value_type='string')
+ db.session.commit()
+ monkeypatch.setattr(DNSProviderService, 'ensure_a_record',
+ classmethod(lambda cls, h, ip: {'created': True, 'record': {}}))
+ monkeypatch.setattr(AdvancedSSLService, 'issue_wildcard_cert',
+ staticmethod(lambda *a, **k: {'success': False, 'error': 'dns plugin missing'}))
+
+ res = SitesHttpsService.setup(provider.id)
+ assert res['success'] is False
+ assert 'dns plugin missing' in res['error']
+ assert SiteDomainService.https_enabled() is False
+
+
+def test_setup_warns_without_server_ip(app, monkeypatch):
+ from app import db
+ from app.services.advanced_ssl_service import AdvancedSSLService
+ from app.services.sites_https_service import SitesHttpsService
+ from app.services.site_domain_service import SiteDomainService
+
+ provider = _mk_provider(db)
+ monkeypatch.setattr(SiteDomainService, 'server_ip', classmethod(lambda cls: None))
+ monkeypatch.setattr(AdvancedSSLService, 'issue_wildcard_cert',
+ staticmethod(lambda *a, **k: {'success': True, 'certificate_path': '/x'}))
+
+ res = SitesHttpsService.setup(provider.id)
+ assert res['success'] is True
+ assert res['warning'] and 'manually' in res['warning'].lower()
+
+
+# ── vhost wiring ────────────────────────────────────────────────────────────
+
+def test_write_vhost_uses_wildcard_cert_when_https_enabled(app, monkeypatch):
+ from app import db
+ from app.models.system_settings import SystemSettings
+ from app.services import nginx_service
+ from app.services.wordpress_service import WordPressService
+
+ user = _mk_user(db)
+ app_row = _mk_app(db, user.id, host='blog.lvh.me') # covered by the lvh.me wildcard
+ SystemSettings.set('sites_https_enabled', True, value_type='boolean')
+ db.session.commit()
+
+ captured = {}
+ monkeypatch.setattr(nginx_service.NginxService, 'create_site',
+ classmethod(lambda cls, **kw: captured.update(kw) or {'success': True}))
+ monkeypatch.setattr(nginx_service.NginxService, 'enable_site', classmethod(lambda cls, name: {'success': True}))
+
+ WordPressService._write_app_vhost(app_row)
+ assert captured['ssl_cert'] == '/etc/letsencrypt/live/lvh.me/fullchain.pem'
+ assert captured['ssl_key'] == '/etc/letsencrypt/live/lvh.me/privkey.pem'
+
+
+def test_write_vhost_no_wildcard_for_custom_domain(app, monkeypatch):
+ from app import db
+ from app.models.domain import Domain
+ from app.models.system_settings import SystemSettings
+ from app.services import nginx_service
+ from app.services.wordpress_service import WordPressService
+
+ user = _mk_user(db, 'o2')
+ app_row = _mk_app(db, user.id, name='shop', host='blog.lvh.me')
+ db.session.add(Domain(name='myshop.com', is_primary=True, application_id=app_row.id)) # not under base
+ db.session.commit()
+ SystemSettings.set('sites_https_enabled', True, value_type='boolean')
+ db.session.commit()
+
+ captured = {}
+ monkeypatch.setattr(nginx_service.NginxService, 'create_site',
+ classmethod(lambda cls, **kw: captured.update(kw) or {'success': True}))
+ monkeypatch.setattr(nginx_service.NginxService, 'enable_site', classmethod(lambda cls, name: {'success': True}))
+
+ WordPressService._write_app_vhost(app_row)
+ assert captured['ssl_cert'] is None # a non-covered domain blocks the wildcard
diff --git a/frontend/src/components/settings/SiteSettingsTab.jsx b/frontend/src/components/settings/SiteSettingsTab.jsx
index 911dce3d..9edcb6c1 100644
--- a/frontend/src/components/settings/SiteSettingsTab.jsx
+++ b/frontend/src/components/settings/SiteSettingsTab.jsx
@@ -1,4 +1,4 @@
-import React, { useState, useEffect } from 'react';
+import { useState, useEffect } from 'react';
import api from '../../services/api';
import { Switch } from '@/components/ui/switch';
import { Label } from '@/components/ui/label';
@@ -15,6 +15,12 @@ const SiteSettingsTab = ({ onDevModeChange }) => {
const [saving, setSaving] = useState(false);
const [savingPort, setSavingPort] = useState(false);
const [message, setMessage] = useState(null);
+ const [https, setHttps] = useState({ base_domain: '', server_ip: '', https_enabled: false, providers: [] });
+ const [baseDomain, setBaseDomain] = useState('');
+ const [serverIp, setServerIp] = useState('');
+ const [providerId, setProviderId] = useState('');
+ const [savingDomain, setSavingDomain] = useState(false);
+ const [settingUpHttps, setSettingUpHttps] = useState(false);
useEffect(() => {
loadSettings();
@@ -28,6 +34,13 @@ const SiteSettingsTab = ({ onDevModeChange }) => {
dev_mode: data.dev_mode || false
});
setBasePort(String(data.managed_app_base_port ?? 0));
+ try {
+ const h = await api.getSitesHttpsStatus();
+ setHttps(h);
+ setBaseDomain(h.base_domain || '');
+ setServerIp(h.server_ip || '');
+ if (h.providers?.length) setProviderId(String(h.providers[0].id));
+ } catch { /* non-admin or endpoint unavailable */ }
} catch (err) {
console.error('Failed to load settings:', err);
} finally {
@@ -35,6 +48,48 @@ const SiteSettingsTab = ({ onDevModeChange }) => {
}
}
+ async function handleSaveDomain() {
+ setSavingDomain(true);
+ setMessage(null);
+ try {
+ await api.updateSystemSetting('sites_base_domain', baseDomain.trim());
+ await api.updateSystemSetting('server_public_ip', serverIp.trim());
+ setMessage({ type: 'success', text: 'Sites domain settings saved' });
+ } catch (err) {
+ setMessage({ type: 'error', text: err.message || 'Failed to save domain settings' });
+ } finally {
+ setSavingDomain(false);
+ }
+ }
+
+ async function handleSetupHttps() {
+ if (!providerId) {
+ setMessage({ type: 'error', text: 'Connect and select a DNS provider first' });
+ return;
+ }
+ setSettingUpHttps(true);
+ setMessage(null);
+ try {
+ // Persist the typed domain/IP first so setup reads current values.
+ await api.updateSystemSetting('sites_base_domain', baseDomain.trim());
+ await api.updateSystemSetting('server_public_ip', serverIp.trim());
+ const res = await api.setupSitesHttps(Number(providerId));
+ if (res.success) {
+ setHttps((h) => ({ ...h, https_enabled: true }));
+ setMessage({
+ type: 'success',
+ text: `Wildcard HTTPS set up for *.${res.base_domain}` + (res.warning ? ` — ${res.warning}` : ''),
+ });
+ } else {
+ setMessage({ type: 'error', text: res.error || 'HTTPS setup failed' });
+ }
+ } catch (err) {
+ setMessage({ type: 'error', text: err.message || 'HTTPS setup failed' });
+ } finally {
+ setSettingUpHttps(false);
+ }
+ }
+
async function handleSaveBasePort() {
const value = parseInt(basePort, 10);
if (Number.isNaN(value) || value < 0 || value > 65535) {
@@ -145,6 +200,93 @@ const SiteSettingsTab = ({ onDevModeChange }) => {
</div>
</div>
+ <div className="settings-card">
+ <h3>Managed Sites Domain &amp; HTTPS</h3>
+ <p>Publish managed sites at <code>&lt;name&gt;.&lt;base-domain&gt;</code>, auto-create their DNS, and serve them over HTTPS with a wildcard certificate.</p>
+
+ <div className="form-group">
+ <div className="settings-row">
+ <div className="settings-label">
+ <Label htmlFor="sites-base-domain">Base domain</Label>
+ </div>
+ <div className="settings-control">
+ <Input
+ id="sites-base-domain"
+ type="text"
+ placeholder="apps.example.com"
+ value={baseDomain}
+ onChange={(e) => setBaseDomain(e.target.value)}
+ className="w-56"
+ />
+ </div>
+ </div>
+ <span className="form-help">
+ Each site is published at <code>&lt;name&gt;.{baseDomain || 'base-domain'}</code>. Point a
+ wildcard DNS record <code>*.{baseDomain || 'base-domain'}</code> at this server.
+ </span>
+ </div>
+
+ <div className="form-group">
+ <div className="settings-row">
+ <div className="settings-label">
+ <Label htmlFor="sites-server-ip">Server public IP</Label>
+ </div>
+ <div className="settings-control">
+ <Input
+ id="sites-server-ip"
+ type="text"
+ placeholder="203.0.113.10"
+ value={serverIp}
+ onChange={(e) => setServerIp(e.target.value)}
+ className="w-56"
+ />
+ <Button onClick={handleSaveDomain} disabled={savingDomain}>
+ {savingDomain ? 'Saving…' : 'Save'}
+ </Button>
+ </div>
+ </div>
+ <span className="form-help">Used to auto-create DNS A records for managed domains.</span>
+ </div>
+
+ <div className="form-group">
+ <div className="settings-row">
+ <div className="settings-label">
+ <Label>Wildcard HTTPS</Label>
+ <span className="form-help">
+ {https.https_enabled
+ ? 'Enabled — managed subdomains serve HTTPS.'
+ : 'Not set up yet.'}
+ </span>
+ </div>
+ <div className="settings-control">
+ {https.providers?.length ? (
+ <select
+ className="settings-select"
+ value={providerId}
+ onChange={(e) => setProviderId(e.target.value)}
+ >
+ {https.providers.map((p) => (
+ <option key={p.id} value={p.id}>{p.name} ({p.provider})</option>
+ ))}
+ </select>
+ ) : (
+ <span className="form-help">Connect a DNS provider under Email → DNS Providers first.</span>
+ )}
+ <Button
+ onClick={handleSetupHttps}
+ disabled={settingUpHttps || !https.providers?.length || !baseDomain.trim()}
+ >
+ {settingUpHttps ? 'Setting up…' : 'Set up wildcard HTTPS'}
+ </Button>
+ </div>
+ </div>
+ <span className="form-help">
+ Creates <code>*.{baseDomain || 'base-domain'}</code> DNS and issues a wildcard
+ Let&apos;s Encrypt certificate via the selected provider (DNS-01).
+ </span>
+ </div>
+ </div>
+
<div className="settings-card">
<h3>Developer Mode</h3>
<p>Enable developer tools and diagnostics.</p>
diff --git a/frontend/src/services/api/system.js b/frontend/src/services/api/system.js
index e0e43ed6..53c27bc2 100644
--- a/frontend/src/services/api/system.js
+++ b/frontend/src/services/api/system.js
@@ -35,6 +35,18 @@ export async function getAdminStats() {
return this.request('/admin/stats');
}
+// Managed-sites domain & HTTPS (Phase 5)
+export async function getSitesHttpsStatus() {
+ return this.request('/admin/sites-https/status');
+}
+
+export async function setupSitesHttps(providerId, email) {
+ return this.request('/admin/sites-https/setup', {
+ method: 'POST',
+ body: { provider_id: providerId, email }
+ });
+}
+
// System endpoints
export async function getSystemMetrics() {
return this.request('/system/metrics');