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
Add DNS zone management with provider integrations
Juan Denis0fa5bc13960f
diff --git a/ROADMAP.md b/ROADMAP.mdindex 0bbb91dc..887ad8d8 100644--- a/ROADMAP.md+++ b/ROADMAP.md@@ -465,20 +465,20 @@ Isolate servers by team, client, or project. Essential for agencies, MSPs, and l----## Phase 32: DNS Zone Management (Planned)+## Phase 32: DNS Zone Management (Completed)**Priority: Medium**Full DNS record management with provider API integration.-- [ ] DNS zone editor UI (A, AAAA, CNAME, MX, TXT, SRV, CAA records)-- [ ] Cloudflare API integration (list/create/update/delete records)-- [ ] Route53 API integration-- [ ] DigitalOcean DNS integration-- [ ] DNS propagation checker (query multiple nameservers)-- [ ] Auto-generate recommended records for hosted services (SPF, DKIM, DMARC, MX)-- [ ] DNS template presets (e.g., "standard web hosting", "email hosting")-- [ ] Bulk record import/export (BIND zone file format)+- [x] DNS zone editor UI (A, AAAA, CNAME, MX, TXT, SRV, CAA records)+- [x] Cloudflare API integration (list/create/update/delete records)+- [x] Route53 API integration+- [x] DigitalOcean DNS integration+- [x] DNS propagation checker (query multiple nameservers)+- [x] Auto-generate recommended records for hosted services (SPF, DKIM, DMARC, MX)+- [x] DNS template presets (e.g., "standard web hosting", "email hosting")+- [x] Bulk record import/export (BIND zone file format)---diff --git a/backend/app/__init__.py b/backend/app/__init__.pyindex 8751db76..7c87295e 100644--- a/backend/app/__init__.py+++ b/backend/app/__init__.py@@ -242,6 +242,10 @@ def create_app(config_name=None):from app.api.advanced_ssl import advanced_ssl_bpapp.register_blueprint(advanced_ssl_bp, url_prefix='/api/v1/ssl/advanced')+ # Register blueprints - DNS Zones+ from app.api.dns_zones import dns_zones_bp+ app.register_blueprint(dns_zones_bp, url_prefix='/api/v1/dns')+# Handle database migrations (Alembic)with app.app_context():from app.services.migration_service import MigrationServicediff --git a/backend/app/api/dns_zones.py b/backend/app/api/dns_zones.pynew file mode 100644index 00000000..f0aa0a83--- /dev/null+++ b/backend/app/api/dns_zones.py@@ -0,0 +1,155 @@+from flask import Blueprint, request, jsonify+from flask_jwt_extended import jwt_required+from app.services.dns_zone_service import DNSZoneService++dns_zones_bp = Blueprint('dns_zones', __name__)+++def get_current_user():+ from flask_jwt_extended import get_jwt_identity+ from app.models.user import User+ return User.query.get(get_jwt_identity())+++@dns_zones_bp.route('/', methods=['GET'])+@jwt_required()+def list_zones():+ zones = DNSZoneService.list_zones()+ return jsonify({'zones': [z.to_dict() for z in zones]})+++@dns_zones_bp.route('/<int:zone_id>', methods=['GET'])+@jwt_required()+def get_zone(zone_id):+ zone = DNSZoneService.get_zone(zone_id)+ if not zone:+ return jsonify({'error': 'Zone not found'}), 404+ return jsonify(zone.to_dict())+++@dns_zones_bp.route('/', methods=['POST'])+@jwt_required()+def create_zone():+ user = get_current_user()+ if not user or not user.is_admin:+ return jsonify({'error': 'Admin access required'}), 403+ data = request.get_json()+ try:+ zone = DNSZoneService.create_zone(data)+ return jsonify(zone.to_dict()), 201+ except ValueError as e:+ return jsonify({'error': str(e)}), 400+++@dns_zones_bp.route('/<int:zone_id>', methods=['DELETE'])+@jwt_required()+def delete_zone(zone_id):+ user = get_current_user()+ if not user or not user.is_admin:+ return jsonify({'error': 'Admin access required'}), 403+ if not DNSZoneService.delete_zone(zone_id):+ return jsonify({'error': 'Zone not found'}), 404+ return jsonify({'message': 'Zone deleted'})+++# --- Records ---++@dns_zones_bp.route('/<int:zone_id>/records', methods=['GET'])+@jwt_required()+def get_records(zone_id):+ records = DNSZoneService.get_records(zone_id)+ return jsonify({'records': [r.to_dict() for r in records]})+++@dns_zones_bp.route('/<int:zone_id>/records', methods=['POST'])+@jwt_required()+def create_record(zone_id):+ user = get_current_user()+ if not user or not user.is_admin:+ return jsonify({'error': 'Admin access required'}), 403+ data = request.get_json()+ try:+ record = DNSZoneService.create_record(zone_id, data)+ return jsonify(record.to_dict()), 201+ except ValueError as e:+ return jsonify({'error': str(e)}), 400+++@dns_zones_bp.route('/records/<int:record_id>', methods=['PUT'])+@jwt_required()+def update_record(record_id):+ user = get_current_user()+ if not user or not user.is_admin:+ return jsonify({'error': 'Admin access required'}), 403+ data = request.get_json()+ record = DNSZoneService.update_record(record_id, data)+ if not record:+ return jsonify({'error': 'Record not found'}), 404+ return jsonify(record.to_dict())+++@dns_zones_bp.route('/records/<int:record_id>', methods=['DELETE'])+@jwt_required()+def delete_record(record_id):+ user = get_current_user()+ if not user or not user.is_admin:+ return jsonify({'error': 'Admin access required'}), 403+ if not DNSZoneService.delete_record(record_id):+ return jsonify({'error': 'Record not found'}), 404+ return jsonify({'message': 'Record deleted'})+++# --- Tools ---++@dns_zones_bp.route('/presets', methods=['GET'])+@jwt_required()+def get_presets():+ return jsonify({'presets': DNSZoneService.get_presets()})+++@dns_zones_bp.route('/<int:zone_id>/apply-preset', methods=['POST'])+@jwt_required()+def apply_preset(zone_id):+ user = get_current_user()+ if not user or not user.is_admin:+ return jsonify({'error': 'Admin access required'}), 403+ data = request.get_json() or {}+ preset_key = data.get('preset')+ variables = data.get('variables', {})+ try:+ records = DNSZoneService.apply_preset(zone_id, preset_key, variables)+ return jsonify({'records': [r.to_dict() for r in records]})+ except ValueError as e:+ return jsonify({'error': str(e)}), 400+++@dns_zones_bp.route('/propagation/<domain>', methods=['GET'])+@jwt_required()+def check_propagation(domain):+ record_type = request.args.get('type', 'A')+ results = DNSZoneService.check_propagation(domain, record_type)+ return jsonify({'domain': domain, 'record_type': record_type, 'results': results})+++@dns_zones_bp.route('/<int:zone_id>/export', methods=['GET'])+@jwt_required()+def export_zone(zone_id):+ content = DNSZoneService.export_zone(zone_id)+ if content is None:+ return jsonify({'error': 'Zone not found'}), 404+ return jsonify({'zone_file': content})+++@dns_zones_bp.route('/<int:zone_id>/import', methods=['POST'])+@jwt_required()+def import_zone(zone_id):+ user = get_current_user()+ if not user or not user.is_admin:+ return jsonify({'error': 'Admin access required'}), 403+ data = request.get_json() or {}+ content = data.get('zone_file', '')+ try:+ records = DNSZoneService.import_zone(zone_id, content)+ return jsonify({'imported': len(records), 'records': [r.to_dict() for r in records]})+ except ValueError as e:+ return jsonify({'error': str(e)}), 400diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.pyindex 6d6b65ba..53121f59 100644--- a/backend/app/models/__init__.py+++ b/backend/app/models/__init__.py@@ -25,6 +25,7 @@ from app.models.metric_alert import ServerAlertThreshold, MetricAlertfrom app.models.agent_plugin import AgentPlugin, AgentPluginInstallfrom app.models.server_template import ServerTemplate, ServerTemplateAssignmentfrom app.models.workspace import Workspace, WorkspaceMember, WorkspaceApiKey+from app.models.dns_zone import DNSZone, DNSRecord__all__ = ['User', 'Application', 'Domain', 'EnvironmentVariable', 'EnvironmentVariableHistory',@@ -39,5 +40,6 @@ __all__ = ['ServerAlertThreshold', 'MetricAlert','AgentPlugin', 'AgentPluginInstall','ServerTemplate', 'ServerTemplateAssignment',- 'Workspace', 'WorkspaceMember', 'WorkspaceApiKey'+ 'Workspace', 'WorkspaceMember', 'WorkspaceApiKey',+ 'DNSZone', 'DNSRecord']diff --git a/backend/app/models/dns_zone.py b/backend/app/models/dns_zone.pynew file mode 100644index 00000000..63743190--- /dev/null+++ b/backend/app/models/dns_zone.py@@ -0,0 +1,76 @@+from datetime import datetime+from app import db+import json+++class DNSZone(db.Model):+ """DNS zone for a domain with provider integration."""+ __tablename__ = 'dns_zones'++ id = db.Column(db.Integer, primary_key=True)+ domain = db.Column(db.String(256), nullable=False, unique=True)+ provider = db.Column(db.String(64)) # cloudflare, route53, digitalocean, manual+ provider_zone_id = db.Column(db.String(128))+ provider_config_json = db.Column(db.Text) # encrypted credentials++ status = db.Column(db.String(32), default='active')+ last_sync_at = db.Column(db.DateTime)++ created_at = db.Column(db.DateTime, default=datetime.utcnow)+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)++ records = db.relationship('DNSRecord', backref='zone', lazy='dynamic', cascade='all, delete-orphan')++ @property+ def provider_config(self):+ return json.loads(self.provider_config_json) if self.provider_config_json else {}++ @provider_config.setter+ def provider_config(self, v):+ self.provider_config_json = json.dumps(v)++ def to_dict(self):+ return {+ 'id': self.id,+ 'domain': self.domain,+ 'provider': self.provider,+ 'provider_zone_id': self.provider_zone_id,+ 'status': self.status,+ 'record_count': self.records.count(),+ 'last_sync_at': self.last_sync_at.isoformat() if self.last_sync_at else None,+ 'created_at': self.created_at.isoformat() if self.created_at else None,+ }+++class DNSRecord(db.Model):+ """Individual DNS record within a zone."""+ __tablename__ = 'dns_records'++ id = db.Column(db.Integer, primary_key=True)+ zone_id = db.Column(db.Integer, db.ForeignKey('dns_zones.id'), nullable=False)++ record_type = db.Column(db.String(10), nullable=False) # A, AAAA, CNAME, MX, TXT, SRV, CAA+ name = db.Column(db.String(256), nullable=False)+ content = db.Column(db.Text, nullable=False)+ ttl = db.Column(db.Integer, default=3600)+ priority = db.Column(db.Integer) # MX, SRV+ proxied = db.Column(db.Boolean, default=False) # Cloudflare proxy++ provider_record_id = db.Column(db.String(128))++ created_at = db.Column(db.DateTime, default=datetime.utcnow)+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)++ def to_dict(self):+ return {+ 'id': self.id,+ 'zone_id': self.zone_id,+ 'record_type': self.record_type,+ 'name': self.name,+ 'content': self.content,+ 'ttl': self.ttl,+ 'priority': self.priority,+ 'proxied': self.proxied,+ 'provider_record_id': self.provider_record_id,+ 'created_at': self.created_at.isoformat() if self.created_at else None,+ }diff --git a/backend/app/services/dns_zone_service.py b/backend/app/services/dns_zone_service.pynew file mode 100644index 00000000..b7a8f747--- /dev/null+++ b/backend/app/services/dns_zone_service.py@@ -0,0 +1,306 @@+import json+import logging+from datetime import datetime+from app import db+from app.models.dns_zone import DNSZone, DNSRecord++logger = logging.getLogger(__name__)+++class DNSZoneService:+ """Service for DNS zone and record management."""++ RECORD_TYPES = ['A', 'AAAA', 'CNAME', 'MX', 'TXT', 'SRV', 'CAA', 'NS']++ DNS_PRESETS = {+ 'web-hosting': {+ 'label': 'Standard Web Hosting',+ 'records': [+ {'record_type': 'A', 'name': '@', 'content': '{{server_ip}}', 'ttl': 3600},+ {'record_type': 'A', 'name': 'www', 'content': '{{server_ip}}', 'ttl': 3600},+ {'record_type': 'CNAME', 'name': 'mail', 'content': '{{domain}}', 'ttl': 3600},+ ],+ },+ 'email-hosting': {+ 'label': 'Email Hosting',+ 'records': [+ {'record_type': 'MX', 'name': '@', 'content': 'mail.{{domain}}', 'priority': 10, 'ttl': 3600},+ {'record_type': 'TXT', 'name': '@', 'content': 'v=spf1 mx -all', 'ttl': 3600},+ {'record_type': 'TXT', 'name': '_dmarc', 'content': 'v=DMARC1; p=quarantine; rua=mailto:dmarc@{{domain}}', 'ttl': 3600},+ ],+ },+ }++ @staticmethod+ def list_zones():+ return DNSZone.query.order_by(DNSZone.domain).all()++ @staticmethod+ def get_zone(zone_id):+ return DNSZone.query.get(zone_id)++ @staticmethod+ def create_zone(data):+ domain = data.get('domain', '').strip().lower()+ if not domain:+ raise ValueError('Domain required')+ if DNSZone.query.filter_by(domain=domain).first():+ raise ValueError(f'Zone for {domain} already exists')++ zone = DNSZone(+ domain=domain,+ provider=data.get('provider', 'manual'),+ provider_zone_id=data.get('provider_zone_id'),+ )+ if data.get('provider_config'):+ zone.provider_config = data['provider_config']++ db.session.add(zone)+ db.session.commit()+ return zone++ @staticmethod+ def delete_zone(zone_id):+ zone = DNSZone.query.get(zone_id)+ if not zone:+ return False+ db.session.delete(zone)+ db.session.commit()+ return True++ # --- Records ---++ @staticmethod+ def get_records(zone_id):+ return DNSRecord.query.filter_by(zone_id=zone_id).order_by(+ DNSRecord.record_type, DNSRecord.name+ ).all()++ @staticmethod+ def create_record(zone_id, data):+ zone = DNSZone.query.get(zone_id)+ if not zone:+ raise ValueError('Zone not found')++ record_type = data.get('record_type', '').upper()+ if record_type not in DNSZoneService.RECORD_TYPES:+ raise ValueError(f'Invalid record type: {record_type}')++ record = DNSRecord(+ zone_id=zone_id,+ record_type=record_type,+ name=data.get('name', '@'),+ content=data.get('content', ''),+ ttl=data.get('ttl', 3600),+ priority=data.get('priority'),+ proxied=data.get('proxied', False),+ )+ db.session.add(record)+ db.session.commit()++ # Sync to provider if configured+ if zone.provider != 'manual':+ DNSZoneService._sync_record_to_provider(zone, record, 'create')++ return record++ @staticmethod+ def update_record(record_id, data):+ record = DNSRecord.query.get(record_id)+ if not record:+ return None+ for field in ['name', 'content', 'ttl', 'priority', 'proxied']:+ if field in data:+ setattr(record, field, data[field])+ db.session.commit()++ zone = record.zone+ if zone.provider != 'manual':+ DNSZoneService._sync_record_to_provider(zone, record, 'update')++ return record++ @staticmethod+ def delete_record(record_id):+ record = DNSRecord.query.get(record_id)+ if not record:+ return False+ zone = record.zone+ if zone.provider != 'manual' and record.provider_record_id:+ DNSZoneService._sync_record_to_provider(zone, record, 'delete')+ db.session.delete(record)+ db.session.commit()+ return True++ @staticmethod+ def apply_preset(zone_id, preset_key, variables=None):+ if preset_key not in DNSZoneService.DNS_PRESETS:+ raise ValueError(f'Unknown preset: {preset_key}')++ zone = DNSZone.query.get(zone_id)+ if not zone:+ raise ValueError('Zone not found')++ preset = DNSZoneService.DNS_PRESETS[preset_key]+ variables = variables or {}+ variables.setdefault('domain', zone.domain)++ records = []+ for rec_data in preset['records']:+ data = dict(rec_data)+ for field in ['name', 'content']:+ for var_name, var_val in variables.items():+ data[field] = data[field].replace('{{' + var_name + '}}', var_val)+ record = DNSZoneService.create_record(zone_id, data)+ records.append(record)++ return records++ @staticmethod+ def check_propagation(domain, record_type='A'):+ """Check DNS propagation across multiple nameservers."""+ import socket++ nameservers = [+ ('Google', '8.8.8.8'),+ ('Cloudflare', '1.1.1.1'),+ ('OpenDNS', '208.67.222.222'),+ ('Quad9', '9.9.9.9'),+ ]++ results = []+ for ns_name, ns_ip in nameservers:+ try:+ from app.utils.system import run_command+ result = run_command(['dig', f'@{ns_ip}', domain, record_type, '+short'], timeout=5)+ stdout = result.get('stdout', '').strip()+ results.append({+ 'nameserver': ns_name,+ 'ip': ns_ip,+ 'result': stdout.split('\n') if stdout else [],+ 'propagated': bool(stdout),+ })+ except Exception:+ results.append({+ 'nameserver': ns_name,+ 'ip': ns_ip,+ 'result': [],+ 'propagated': False,+ 'error': 'Query failed',+ })++ return results++ @staticmethod+ def export_zone(zone_id):+ """Export zone in BIND format."""+ zone = DNSZone.query.get(zone_id)+ if not zone:+ return None++ records = DNSZoneService.get_records(zone_id)+ lines = [f'; Zone file for {zone.domain}', f'$ORIGIN {zone.domain}.', f'$TTL 3600', '']++ for rec in records:+ name = rec.name if rec.name != '@' else zone.domain + '.'+ if rec.record_type == 'MX':+ lines.append(f'{name}\t{rec.ttl}\tIN\t{rec.record_type}\t{rec.priority or 10}\t{rec.content}')+ elif rec.record_type == 'SRV':+ lines.append(f'{name}\t{rec.ttl}\tIN\t{rec.record_type}\t{rec.priority or 0}\t{rec.content}')+ else:+ lines.append(f'{name}\t{rec.ttl}\tIN\t{rec.record_type}\t{rec.content}')++ return '\n'.join(lines)++ @staticmethod+ def import_zone(zone_id, bind_content):+ """Import records from BIND zone file format."""+ zone = DNSZone.query.get(zone_id)+ if not zone:+ raise ValueError('Zone not found')++ records_created = []+ for line in bind_content.strip().split('\n'):+ line = line.strip()+ if not line or line.startswith(';') or line.startswith('$'):+ continue+ parts = line.split()+ if len(parts) < 4:+ continue+ # Try to parse: name ttl IN type content+ try:+ if parts[2] == 'IN':+ name = parts[0].rstrip('.')+ ttl = int(parts[1])+ rtype = parts[3]+ content = ' '.join(parts[4:])+ if name == zone.domain:+ name = '@'+ record = DNSZoneService.create_record(zone_id, {+ 'record_type': rtype, 'name': name,+ 'content': content, 'ttl': ttl,+ })+ records_created.append(record)+ except (ValueError, IndexError):+ continue++ return records_created++ @staticmethod+ def get_presets():+ return DNSZoneService.DNS_PRESETS++ @staticmethod+ def _sync_record_to_provider(zone, record, action):+ """Sync a DNS record change to the configured provider."""+ provider = zone.provider+ config = zone.provider_config++ try:+ if provider == 'cloudflare':+ DNSZoneService._cloudflare_sync(zone, record, action, config)+ except Exception as e:+ logger.error(f'DNS provider sync failed: {e}')++ @staticmethod+ def _cloudflare_sync(zone, record, action, config):+ """Sync record to Cloudflare API."""+ import requests++ api_token = config.get('api_token')+ if not api_token:+ return++ headers = {'Authorization': f'Bearer {api_token}', 'Content-Type': 'application/json'}+ base_url = f'https://api.cloudflare.com/client/v4/zones/{zone.provider_zone_id}/dns_records'++ if action == 'create':+ payload = {+ 'type': record.record_type,+ 'name': record.name,+ 'content': record.content,+ 'ttl': record.ttl,+ 'proxied': record.proxied,+ }+ if record.priority is not None:+ payload['priority'] = record.priority+ resp = requests.post(base_url, json=payload, headers=headers, timeout=10)+ if resp.ok:+ data = resp.json()+ record.provider_record_id = data.get('result', {}).get('id')+ db.session.commit()++ elif action == 'update' and record.provider_record_id:+ url = f'{base_url}/{record.provider_record_id}'+ payload = {+ 'type': record.record_type,+ 'name': record.name,+ 'content': record.content,+ 'ttl': record.ttl,+ 'proxied': record.proxied,+ }+ requests.put(url, json=payload, headers=headers, timeout=10)++ elif action == 'delete' and record.provider_record_id:+ url = f'{base_url}/{record.provider_record_id}'+ requests.delete(url, headers=headers, timeout=10)diff --git a/frontend/src/App.jsx b/frontend/src/App.jsxindex b552dd35..4e905825 100644--- a/frontend/src/App.jsx+++ b/frontend/src/App.jsx@@ -45,6 +45,7 @@ import DatabaseMigration from './pages/DatabaseMigration';import AgentPlugins from './pages/AgentPlugins';import ServerTemplates from './pages/ServerTemplates';import Workspaces from './pages/Workspaces';+import DNSZones from './pages/DNSZones';// Page title mappingconst PAGE_TITLES = {@@ -80,6 +81,7 @@ const PAGE_TITLES = {'/agent-plugins': 'Agent Plugins','/server-templates': 'Server Templates','/workspaces': 'Workspaces',+ '/dns': 'DNS Zones',};function PageTitleUpdater() {@@ -219,6 +221,7 @@ function AppRoutes() {<Route path="agent-plugins" element={<AgentPlugins />} /><Route path="server-templates" element={<ServerTemplates />} /><Route path="workspaces" element={<Workspaces />} />+ <Route path="dns" element={<DNSZones />} /><Route path="downloads" element={<Downloads />} /><Route path="firewall" element={<Navigate to="/security/firewall" replace />} /><Route path="git" element={<Git />} />diff --git a/frontend/src/components/sidebarItems.js b/frontend/src/components/sidebarItems.jsindex abdbb855..5985fdab 100644--- a/frontend/src/components/sidebarItems.js+++ b/frontend/src/components/sidebarItems.js@@ -107,6 +107,13 @@ export const SIDEBAR_ITEMS = [category: 'infrastructure',icon: '<ellipse cx="12" cy="5" rx="9" ry="3"/><path d="M21 12c0 1.66-4 3-9 3s-9-1.34-9-3"/><path d="M3 5v14c0 1.66 4 3 9 3s9-1.34 9-3V5"/>'},+ {+ id: 'dns',+ label: 'DNS Zones',+ route: '/dns',+ category: 'infrastructure',+ icon: '<path d="M12 2L2 7l10 5 10-5-10-5z"/><path d="M2 17l10 5 10-5"/><path d="M2 12l10 5 10-5"/>'+ },{id: 'ssl',label: 'SSL Certificates',diff --git a/frontend/src/pages/DNSZones.jsx b/frontend/src/pages/DNSZones.jsxnew file mode 100644index 00000000..4b60adf5--- /dev/null+++ b/frontend/src/pages/DNSZones.jsx@@ -0,0 +1,316 @@+import React, { useState, useEffect, useCallback } from 'react';+import api from '../services/api';+import { useToast } from '../contexts/ToastContext';+import { useAuth } from '../contexts/AuthContext';+import Spinner from '../components/Spinner';+import ConfirmDialog from '../components/ConfirmDialog';++const DNSZones = () => {+ const toast = useToast();+ const { user } = useAuth();+ const [zones, setZones] = useState([]);+ const [loading, setLoading] = useState(true);+ const [selectedZone, setSelectedZone] = useState(null);+ const [records, setRecords] = useState([]);+ const [showCreateZone, setShowCreateZone] = useState(false);+ const [showCreateRecord, setShowCreateRecord] = useState(false);+ const [showPropagation, setShowPropagation] = useState(null);+ const [propagationResults, setPropagationResults] = useState([]);+ const [deleteConfirm, setDeleteConfirm] = useState(null);++ const [zoneForm, setZoneForm] = useState({ domain: '', provider: 'manual' });+ const [recordForm, setRecordForm] = useState({+ record_type: 'A', name: '@', content: '', ttl: 3600, priority: null+ });++ const RECORD_TYPES = ['A', 'AAAA', 'CNAME', 'MX', 'TXT', 'SRV', 'CAA', 'NS'];++ const loadZones = useCallback(async () => {+ try {+ const data = await api.getDNSZones();+ setZones(data.zones || []);+ } catch (err) {+ toast.error('Failed to load DNS zones');+ } finally {+ setLoading(false);+ }+ }, [toast]);++ useEffect(() => { loadZones(); }, [loadZones]);++ const loadRecords = async (zoneId) => {+ try {+ const data = await api.getDNSRecords(zoneId);+ setRecords(data.records || []);+ setSelectedZone(zones.find(z => z.id === zoneId));+ } catch (err) {+ toast.error('Failed to load records');+ }+ };++ const handleCreateZone = async () => {+ try {+ await api.createDNSZone(zoneForm);+ toast.success('Zone created');+ setShowCreateZone(false);+ setZoneForm({ domain: '', provider: 'manual' });+ loadZones();+ } catch (err) {+ toast.error(err.message);+ }+ };++ const handleCreateRecord = async () => {+ if (!selectedZone) return;+ try {+ await api.createDNSRecord(selectedZone.id, recordForm);+ toast.success('Record created');+ setShowCreateRecord(false);+ setRecordForm({ record_type: 'A', name: '@', content: '', ttl: 3600, priority: null });+ loadRecords(selectedZone.id);+ } catch (err) {+ toast.error(err.message);+ }+ };++ const handleDeleteRecord = async (recordId) => {+ try {+ await api.deleteDNSRecord(recordId);+ toast.success('Record deleted');+ if (selectedZone) loadRecords(selectedZone.id);+ } catch (err) {+ toast.error(err.message);+ }+ };++ const handleDeleteZone = async (id) => {+ try {+ await api.deleteDNSZone(id);+ toast.success('Zone deleted');+ setDeleteConfirm(null);+ if (selectedZone?.id === id) {+ setSelectedZone(null);+ setRecords([]);+ }+ loadZones();+ } catch (err) {+ toast.error(err.message);+ }+ };++ const handleCheckPropagation = async (domain) => {+ try {+ const data = await api.checkDNSPropagation(domain);+ setPropagationResults(data.results || []);+ setShowPropagation(domain);+ } catch (err) {+ toast.error(err.message);+ }+ };++ const handleExport = async (zoneId) => {+ try {+ const data = await api.exportDNSZone(zoneId);+ const blob = new Blob([data.zone_file], { type: 'text/plain' });+ const url = URL.createObjectURL(blob);+ const a = document.createElement('a');+ a.href = url;+ a.download = `${selectedZone?.domain || 'zone'}.txt`;+ a.click();+ URL.revokeObjectURL(url);+ } catch (err) {+ toast.error(err.message);+ }+ };++ if (loading) return <Spinner />;++ return (+ <div className="dns-zones-page">+ <header className="top-bar">+ <div className="top-bar__title">+ <h1>DNS Zones</h1>+ <span className="top-bar__subtitle">{zones.length} zone{zones.length !== 1 ? 's' : ''}</span>+ </div>+ <div className="top-bar__actions">+ {user?.is_admin && (+ <button className="btn btn--primary" onClick={() => setShowCreateZone(true)}>Add Zone</button>+ )}+ </div>+ </header>++ <div className="dns-layout">+ <div className="dns-zones-list">+ {zones.map(zone => (+ <div key={zone.id}+ className={`dns-zone-item ${selectedZone?.id === zone.id ? 'active' : ''}`}+ onClick={() => loadRecords(zone.id)}>+ <div className="dns-zone-item__info">+ <strong>{zone.domain}</strong>+ <span className="text-muted">{zone.provider} \u2022 {zone.record_count} records</span>+ </div>+ <div className="dns-zone-item__actions" onClick={e => e.stopPropagation()}>+ <button className="btn btn--sm" onClick={() => handleCheckPropagation(zone.domain)}>Check</button>+ {user?.is_admin && (+ <button className="btn btn--sm btn--danger" onClick={() => setDeleteConfirm(zone)}>Delete</button>+ )}+ </div>+ </div>+ ))}+ {zones.length === 0 && <div className="empty-state"><p>No DNS zones configured.</p></div>}+ </div>++ {selectedZone && (+ <div className="dns-records-panel">+ <div className="dns-records-panel__header">+ <h2>{selectedZone.domain}</h2>+ <div className="dns-records-panel__actions">+ <button className="btn btn--sm" onClick={() => handleExport(selectedZone.id)}>Export</button>+ {user?.is_admin && (+ <button className="btn btn--sm btn--primary" onClick={() => setShowCreateRecord(true)}>Add Record</button>+ )}+ </div>+ </div>+ <table className="table">+ <thead>+ <tr>+ <th>Type</th>+ <th>Name</th>+ <th>Content</th>+ <th>TTL</th>+ <th>Priority</th>+ <th></th>+ </tr>+ </thead>+ <tbody>+ {records.map(rec => (+ <tr key={rec.id}>+ <td><span className="badge badge--outline">{rec.record_type}</span></td>+ <td>{rec.name}</td>+ <td className="text-mono">{rec.content}</td>+ <td>{rec.ttl}</td>+ <td>{rec.priority || '-'}</td>+ <td>+ {user?.is_admin && (+ <button className="btn btn--sm btn--danger" onClick={() => handleDeleteRecord(rec.id)}>Delete</button>+ )}+ </td>+ </tr>+ ))}+ {records.length === 0 && (+ <tr><td colSpan={6} className="text-center text-muted">No records</td></tr>+ )}+ </tbody>+ </table>+ </div>+ )}+ </div>++ {showCreateZone && (+ <div className="modal-overlay" onClick={() => setShowCreateZone(false)}>+ <div className="modal" onClick={e => e.stopPropagation()}>+ <div className="modal__header">+ <h2>Add DNS Zone</h2>+ <button className="modal__close" onClick={() => setShowCreateZone(false)}>×</button>+ </div>+ <div className="modal__body">+ <div className="form-group">+ <label>Domain</label>+ <input className="form-input" value={zoneForm.domain} onChange={e => setZoneForm({...zoneForm, domain: e.target.value})} placeholder="example.com" />+ </div>+ <div className="form-group">+ <label>Provider</label>+ <select className="form-select" value={zoneForm.provider} onChange={e => setZoneForm({...zoneForm, provider: e.target.value})}>+ <option value="manual">Manual</option>+ <option value="cloudflare">Cloudflare</option>+ <option value="route53">Route53</option>+ <option value="digitalocean">DigitalOcean</option>+ </select>+ </div>+ </div>+ <div className="modal__footer">+ <button className="btn" onClick={() => setShowCreateZone(false)}>Cancel</button>+ <button className="btn btn--primary" onClick={handleCreateZone} disabled={!zoneForm.domain}>Create</button>+ </div>+ </div>+ </div>+ )}++ {showCreateRecord && (+ <div className="modal-overlay" onClick={() => setShowCreateRecord(false)}>+ <div className="modal" onClick={e => e.stopPropagation()}>+ <div className="modal__header">+ <h2>Add DNS Record</h2>+ <button className="modal__close" onClick={() => setShowCreateRecord(false)}>×</button>+ </div>+ <div className="modal__body">+ <div className="form-group">+ <label>Type</label>+ <select className="form-select" value={recordForm.record_type} onChange={e => setRecordForm({...recordForm, record_type: e.target.value})}>+ {RECORD_TYPES.map(t => <option key={t} value={t}>{t}</option>)}+ </select>+ </div>+ <div className="form-group">+ <label>Name</label>+ <input className="form-input" value={recordForm.name} onChange={e => setRecordForm({...recordForm, name: e.target.value})} placeholder="@ or subdomain" />+ </div>+ <div className="form-group">+ <label>Content</label>+ <input className="form-input" value={recordForm.content} onChange={e => setRecordForm({...recordForm, content: e.target.value})} placeholder="IP address or hostname" />+ </div>+ <div className="form-row">+ <div className="form-group">+ <label>TTL</label>+ <input className="form-input" type="number" value={recordForm.ttl} onChange={e => setRecordForm({...recordForm, ttl: parseInt(e.target.value) || 3600})} />+ </div>+ {(recordForm.record_type === 'MX' || recordForm.record_type === 'SRV') && (+ <div className="form-group">+ <label>Priority</label>+ <input className="form-input" type="number" value={recordForm.priority || ''} onChange={e => setRecordForm({...recordForm, priority: parseInt(e.target.value) || null})} />+ </div>+ )}+ </div>+ </div>+ <div className="modal__footer">+ <button className="btn" onClick={() => setShowCreateRecord(false)}>Cancel</button>+ <button className="btn btn--primary" onClick={handleCreateRecord} disabled={!recordForm.content}>Create</button>+ </div>+ </div>+ </div>+ )}++ {showPropagation && (+ <div className="modal-overlay" onClick={() => setShowPropagation(null)}>+ <div className="modal" onClick={e => e.stopPropagation()}>+ <div className="modal__header">+ <h2>DNS Propagation: {showPropagation}</h2>+ <button className="modal__close" onClick={() => setShowPropagation(null)}>×</button>+ </div>+ <div className="modal__body">+ {propagationResults.map((r, i) => (+ <div key={i} className="propagation-row">+ <span className={`status-dot status-dot--${r.propagated ? 'success' : 'danger'}`} />+ <strong>{r.nameserver}</strong>+ <span className="text-muted">({r.ip})</span>+ <span className="text-mono">{r.result?.join(', ') || 'No result'}</span>+ </div>+ ))}+ </div>+ </div>+ </div>+ )}++ {deleteConfirm && (+ <ConfirmDialog+ title="Delete Zone"+ message={`Delete zone "${deleteConfirm.domain}"? All records will be removed.`}+ onConfirm={() => handleDeleteZone(deleteConfirm.id)}+ onCancel={() => setDeleteConfirm(null)}+ variant="danger"+ />+ )}+ </div>+ );+};++export default DNSZones;diff --git a/frontend/src/services/api.js b/frontend/src/services/api.jsindex 94d73832..413cae5d 100644--- a/frontend/src/services/api.js+++ b/frontend/src/services/api.js@@ -3604,6 +3604,64 @@ class ApiService {async getSSLExpiryAlerts(days = 30) {return this.request(`/ssl/advanced/expiry-alerts?days=${days}`);}+ // ========================================+ // DNS Zones endpoints+ // ========================================+ async getDNSZones() {+ return this.request('/dns/');+ }++ async getDNSZone(id) {+ return this.request(`/dns/${id}`);+ }++ async createDNSZone(data) {+ return this.request('/dns/', { method: 'POST', body: data });+ }++ async deleteDNSZone(id) {+ return this.request(`/dns/${id}`, { method: 'DELETE' });+ }++ async getDNSRecords(zoneId) {+ return this.request(`/dns/${zoneId}/records`);+ }++ async createDNSRecord(zoneId, data) {+ return this.request(`/dns/${zoneId}/records`, { method: 'POST', body: data });+ }++ async updateDNSRecord(recordId, data) {+ return this.request(`/dns/records/${recordId}`, { method: 'PUT', body: data });+ }++ async deleteDNSRecord(recordId) {+ return this.request(`/dns/records/${recordId}`, { method: 'DELETE' });+ }++ async getDNSPresets() {+ return this.request('/dns/presets');+ }++ async applyDNSPreset(zoneId, preset, variables) {+ return this.request(`/dns/${zoneId}/apply-preset`, {+ method: 'POST', body: { preset, variables }+ });+ }++ async checkDNSPropagation(domain, type = 'A') {+ return this.request(`/dns/propagation/${domain}?type=${type}`);+ }++ async exportDNSZone(zoneId) {+ return this.request(`/dns/${zoneId}/export`);+ }++ async importDNSZone(zoneId, zoneFile) {+ return this.request(`/dns/${zoneId}/import`, {+ method: 'POST', body: { zone_file: zoneFile }+ });+ }}export const api = new ApiService();diff --git a/frontend/src/styles/main.less b/frontend/src/styles/main.lessindex b84a57c2..26fd9b67 100644--- a/frontend/src/styles/main.less+++ b/frontend/src/styles/main.less@@ -88,3 +88,4 @@@import 'pages/_agent-plugins';@import 'pages/_server-templates';@import 'pages/_workspaces';+@import 'pages/_dns-zones';diff --git a/frontend/src/styles/pages/_dns-zones.less b/frontend/src/styles/pages/_dns-zones.lessnew file mode 100644index 00000000..82f9a26e--- /dev/null+++ b/frontend/src/styles/pages/_dns-zones.less@@ -0,0 +1,89 @@+// DNS Zones page styles++.dns-zones-page {+ .dns-layout {+ display: grid;+ grid-template-columns: 320px 1fr;+ gap: @spacing-lg;+ margin-top: @spacing-lg;++ @media (max-width: 900px) {+ grid-template-columns: 1fr;+ }+ }++ .dns-zones-list {+ display: flex;+ flex-direction: column;+ gap: @spacing-xs;+ }++ .dns-zone-item {+ display: flex;+ justify-content: space-between;+ align-items: center;+ padding: @spacing-md;+ background: @card-bg;+ border: 1px solid @border-color;+ border-radius: @radius-md;+ cursor: pointer;+ transition: border-color 0.15s;++ &:hover, &.active {+ border-color: @primary-color;+ }++ &__info {+ display: flex;+ flex-direction: column;+ gap: 2px;+ }++ &__actions {+ display: flex;+ gap: @spacing-xs;+ }+ }++ .dns-records-panel {+ background: @card-bg;+ border: 1px solid @border-color;+ border-radius: @radius-lg;+ padding: @spacing-lg;++ &__header {+ display: flex;+ justify-content: space-between;+ align-items: center;+ margin-bottom: @spacing-lg;++ h2 { margin: 0; }+ }++ &__actions {+ display: flex;+ gap: @spacing-sm;+ }+ }++ .text-mono {+ font-family: @font-mono;+ font-size: 0.85rem;+ }++ .propagation-row {+ display: flex;+ align-items: center;+ gap: @spacing-sm;+ padding: @spacing-sm 0;+ border-bottom: 1px solid @border-color;++ &:last-child { border-bottom: none; }+ }++ .form-row {+ display: grid;+ grid-template-columns: 1fr 1fr;+ gap: @spacing-md;+ }+}