ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.
Python astracloudflarecontrol-panelcyberpaneldnsfablehosting-control-panelhosting-panelkimi-k3server-managementserverkitubuntu-web-panelwebserver
feat(sites): wildcard HTTPS for managed subdomains
Juan Denis0a74e5670d2f
diff --git a/backend/app/api/admin.py b/backend/app/api/admin.pyindex 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.pyindex 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 osos.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.pyindex 3d2d693e..f0f6439b 100644--- a/backend/app/services/nginx_service.py+++ b/backend/app/services/nginx_service.py@@ -389,8 +389,14 @@ location /p/ {{@classmethoddef 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 fileconfig_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+@classmethoddef 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.pyindex 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.pyindex 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)+@staticmethoddef 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.pynew file mode 100644index 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.pyindex 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 Domainfrom app.services.nginx_service import NginxService+ from app.services.site_domain_service import SiteDomainServiceif 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.pynew file mode 100644index 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'},+ email='[email protected]')+ 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 wildcarddiff --git a/frontend/src/components/settings/SiteSettingsTab.jsx b/frontend/src/components/settings/SiteSettingsTab.jsxindex 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 & HTTPS</h3>+ <p>Publish managed sites at <code><name>.<base-domain></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><name>.{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'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.jsindex 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 endpointsexport async function getSystemMetrics() {return this.request('/system/metrics');