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.

Add auth checks, logging, DNS API & UI

Juan Denis6c41e887011a
diff --cc .gitignore
index 6004008f,26e52b30..29f74047
--- a/.gitignore
+++ b/.gitignore
@@@ -79,19 -48,16 +79,20 @@@ Thumbs.d
.mcp.json
new_templates/
/.marketing/
-
-# Test artifacts
-*.test
-*.out
-/template-icons
-
-# Dev data directory (local development path overrides)
-backend/dev-data/
-/.vscode
-/.vscode1
-/.pr
-/.reviews
+/template-icons/
+/.pr/
+/.reviews/
/.claude/settings.local.json
+/serverkit.db
+/backend/instance/serverkit.db
+
+# Logs & Temp
+*.log
+*.tmp
+*.temp
+/logs/
+/tmp/
+nul
+SECURITY_AUDIT.md
+APP_IMPROVEMENTS.md
++*.png
diff --cc backend/app/api/cloud_provisioning.py
index b8c16944,00000000..c8a806e3
mode 100644,000000..100644
--- a/backend/app/api/cloud_provisioning.py
+++ b/backend/app/api/cloud_provisioning.py
@@@ -1,159 -1,0 +1,162 @@@
+from flask import Blueprint, request, jsonify
+from flask_jwt_extended import jwt_required
+from app.services.cloud_provisioning_service import CloudProvisioningService
+
+cloud_provisioning_bp = Blueprint('cloud_provisioning', __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())
+
+
+# --- Providers ---
+
+@cloud_provisioning_bp.route('/providers', methods=['GET'])
+@jwt_required()
+def list_providers():
+ providers = CloudProvisioningService.list_providers()
+ return jsonify({'providers': [p.to_dict() for p in providers]})
+
+
+@cloud_provisioning_bp.route('/providers', methods=['POST'])
+@jwt_required()
+def create_provider():
+ user = get_current_user()
+ if not user or not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json()
+ try:
+ provider = CloudProvisioningService.create_provider(data, user.id)
+ return jsonify(provider.to_dict()), 201
+ except ValueError as e:
+ return jsonify({'error': str(e)}), 400
+
+
+@cloud_provisioning_bp.route('/providers/<int:provider_id>', methods=['DELETE'])
+@jwt_required()
+def delete_provider(provider_id):
+ user = get_current_user()
+ if not user or not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ if not CloudProvisioningService.delete_provider(provider_id):
+ return jsonify({'error': 'Not found'}), 404
+ return jsonify({'message': 'Provider removed'})
+
+
+@cloud_provisioning_bp.route('/providers/<provider_type>/options', methods=['GET'])
+@jwt_required()
+def get_options(provider_type):
+ options = CloudProvisioningService.get_provider_options(provider_type)
+ if not options:
+ return jsonify({'error': 'Unknown provider'}), 404
+ return jsonify(options)
+
+
+# --- Servers ---
+
+@cloud_provisioning_bp.route('/servers', methods=['GET'])
+@jwt_required()
+def list_servers():
+ provider_id = request.args.get('provider_id', type=int)
+ servers = CloudProvisioningService.list_servers(provider_id)
+ return jsonify({'servers': [s.to_dict() for s in servers]})
+
+
+@cloud_provisioning_bp.route('/servers/<int:server_id>', methods=['GET'])
+@jwt_required()
+def get_server(server_id):
+ server = CloudProvisioningService.get_server(server_id)
+ if not server:
+ return jsonify({'error': 'Not found'}), 404
+ return jsonify(server.to_dict())
+
+
+@cloud_provisioning_bp.route('/servers', methods=['POST'])
+@jwt_required()
+def create_server():
+ user = get_current_user()
+ if not user or not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json()
+ if not data or 'name' not in data or 'provider_id' not in data:
+ return jsonify({'error': 'name and provider_id required'}), 400
+ try:
+ server = CloudProvisioningService.create_server(data, user.id)
+ return jsonify(server.to_dict()), 201
+ except (ValueError, Exception) as e:
+ return jsonify({'error': str(e)}), 400
+
+
+@cloud_provisioning_bp.route('/servers/<int:server_id>', methods=['DELETE'])
+@jwt_required()
+def destroy_server(server_id):
+ user = get_current_user()
+ if not user or not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ if not CloudProvisioningService.destroy_server(server_id):
+ return jsonify({'error': 'Not found'}), 404
+ return jsonify({'message': 'Server destroyed'})
+
+
+@cloud_provisioning_bp.route('/servers/<int:server_id>/resize', methods=['POST'])
+@jwt_required()
+def resize_server(server_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 {}
+ new_size = data.get('size')
+ if not new_size:
+ return jsonify({'error': 'size required'}), 400
+ try:
+ server = CloudProvisioningService.resize_server(server_id, new_size)
+ if not server:
+ return jsonify({'error': 'Not found'}), 404
+ return jsonify(server.to_dict())
+ except ValueError as e:
+ return jsonify({'error': str(e)}), 400
+
+
+# --- Snapshots ---
+
+@cloud_provisioning_bp.route('/servers/<int:server_id>/snapshots', methods=['GET'])
+@jwt_required()
+def list_snapshots(server_id):
+ snapshots = CloudProvisioningService.get_snapshots(server_id)
+ return jsonify({'snapshots': [s.to_dict() for s in snapshots]})
+
+
+@cloud_provisioning_bp.route('/servers/<int:server_id>/snapshots', methods=['POST'])
+@jwt_required()
+def create_snapshot(server_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 {}
+ name = data.get('name', f'snapshot-{server_id}')
+ try:
+ snapshot = CloudProvisioningService.create_snapshot(server_id, name)
+ return jsonify(snapshot.to_dict()), 201
+ except ValueError as e:
+ return jsonify({'error': str(e)}), 400
+
+
+@cloud_provisioning_bp.route('/snapshots/<int:snapshot_id>', methods=['DELETE'])
+@jwt_required()
+def delete_snapshot(snapshot_id):
++ user = get_current_user()
++ if not user or not user.is_admin:
++ return jsonify({'error': 'Admin access required'}), 403
+ if not CloudProvisioningService.delete_snapshot(snapshot_id):
+ return jsonify({'error': 'Not found'}), 404
+ return jsonify({'message': 'Snapshot deleted'})
+
+
+# --- Cost ---
+
+@cloud_provisioning_bp.route('/costs', methods=['GET'])
+@jwt_required()
+def cost_summary():
+ return jsonify(CloudProvisioningService.get_cost_summary())
diff --cc backend/app/api/fleet_monitor.py
index 7e88484d,00000000..6929ffa2
mode 100644,000000..100644
--- a/backend/app/api/fleet_monitor.py
+++ b/backend/app/api/fleet_monitor.py
@@@ -1,198 -1,0 +1,198 @@@
+"""
+Fleet Monitor API
+
+Endpoints for fleet-wide monitoring: heatmaps, comparisons,
+alert thresholds, anomaly detection, capacity forecasting,
+fleet search, and metrics export.
+"""
+
+import os
+from flask import Blueprint, request, jsonify, Response
+from flask_jwt_extended import jwt_required, get_jwt_identity
+
+from app.services.fleet_monitor_service import fleet_monitor_service
+from app.middleware.rbac import admin_required
+
+fleet_monitor_bp = Blueprint('fleet_monitor', __name__)
+
+
+# ==================== Heatmap ====================
+
+@fleet_monitor_bp.route('/heatmap', methods=['GET'])
+@jwt_required()
+def get_fleet_heatmap():
+ """Get latest metrics for all servers in heatmap format."""
+ group_id = request.args.get('group_id')
+ return jsonify(fleet_monitor_service.get_fleet_heatmap(group_id))
+
+
+# ==================== Comparison ====================
+
+@fleet_monitor_bp.route('/comparison', methods=['GET'])
+@jwt_required()
+def get_comparison():
+ """Get multi-server comparison time-series."""
+ ids_param = request.args.get('ids', '')
+ server_ids = [s.strip() for s in ids_param.split(',') if s.strip()]
+ metric = request.args.get('metric', 'cpu')
+ period = request.args.get('period', '24h')
+
+ if not server_ids:
+ return jsonify({'error': 'ids parameter is required'}), 400
+
+ return jsonify(fleet_monitor_service.get_comparison_timeseries(server_ids, metric, period))
+
+
+# ==================== Alerts ====================
+
+@fleet_monitor_bp.route('/alerts', methods=['GET'])
+@jwt_required()
+def get_alerts():
+ """Get metric alerts."""
+ status = request.args.get('status')
+ severity = request.args.get('severity')
+ server_id = request.args.get('server_id')
+ limit = request.args.get('limit', 50, type=int)
+
+ return jsonify(fleet_monitor_service.get_alerts(status, severity, server_id, limit))
+
+
+@fleet_monitor_bp.route('/alerts/<alert_id>/acknowledge', methods=['POST'])
+@jwt_required()
+def acknowledge_alert(alert_id):
+ """Acknowledge an active alert."""
+ user_id = get_jwt_identity()
+ success = fleet_monitor_service.acknowledge_alert(alert_id, user_id)
+ if not success:
+ return jsonify({'error': 'Cannot acknowledge alert'}), 400
+ return jsonify({'success': True})
+
+
+@fleet_monitor_bp.route('/alerts/<alert_id>/resolve', methods=['POST'])
+@jwt_required()
+def resolve_alert(alert_id):
+ """Resolve an alert."""
+ success = fleet_monitor_service.resolve_alert(alert_id)
+ if not success:
+ return jsonify({'error': 'Cannot resolve alert'}), 400
+ return jsonify({'success': True})
+
+
+# ==================== Thresholds ====================
+
+@fleet_monitor_bp.route('/thresholds', methods=['GET'])
+@jwt_required()
+def get_thresholds():
+ """Get alert thresholds."""
+ server_id = request.args.get('server_id')
+ return jsonify(fleet_monitor_service.get_thresholds(server_id))
+
+
+@fleet_monitor_bp.route('/thresholds', methods=['POST'])
+@jwt_required()
+@admin_required
+def create_threshold():
+ """Create or update an alert threshold."""
+ data = request.get_json()
+ result = fleet_monitor_service.upsert_threshold(data)
+ if 'error' in result:
+ return jsonify(result), 400
+ return jsonify(result), 201
+
+
+@fleet_monitor_bp.route('/thresholds/<threshold_id>', methods=['DELETE'])
+@jwt_required()
+@admin_required
+def delete_threshold(threshold_id):
+ """Delete an alert threshold."""
+ success = fleet_monitor_service.delete_threshold(threshold_id)
+ if not success:
+ return jsonify({'error': 'Threshold not found'}), 404
+ return jsonify({'success': True})
+
+
+# ==================== Anomalies ====================
+
+@fleet_monitor_bp.route('/anomalies', methods=['GET'])
+@jwt_required()
+def get_anomalies():
+ """Get anomaly detection results."""
+ server_id = request.args.get('server_id')
+ return jsonify(fleet_monitor_service.detect_anomalies(server_id))
+
+
+# ==================== Capacity Forecast ====================
+
+@fleet_monitor_bp.route('/forecast/<server_id>', methods=['GET'])
+@jwt_required()
+def get_forecast(server_id):
+ """Get capacity forecast for a server."""
+ metric = request.args.get('metric', 'disk')
+ return jsonify(fleet_monitor_service.forecast_capacity(server_id, metric))
+
+
+# ==================== Fleet Search ====================
+
+@fleet_monitor_bp.route('/search', methods=['GET'])
+@jwt_required()
+def search_fleet():
+ """Search across fleet for servers, containers, services, ports."""
+ query = request.args.get('q', '')
+ search_type = request.args.get('type', 'any')
+
+ if not query or len(query) < 2:
+ return jsonify({'error': 'Query must be at least 2 characters'}), 400
+
+ return jsonify(fleet_monitor_service.search_fleet(query, search_type))
+
+
+# ==================== Export ====================
+
+@fleet_monitor_bp.route('/export/csv', methods=['GET'])
+@jwt_required()
+def export_csv():
+ """Export metrics as CSV download."""
+ ids_param = request.args.get('ids', '')
+ server_ids = [s.strip() for s in ids_param.split(',') if s.strip()]
+ metric = request.args.get('metric', 'cpu')
+ period = request.args.get('period', '24h')
+
+ if not server_ids:
+ return jsonify({'error': 'ids parameter is required'}), 400
+
+ csv_data = fleet_monitor_service.export_metrics_csv(server_ids, metric, period)
+ return Response(
+ csv_data,
+ mimetype='text/csv',
+ headers={'Content-Disposition': f'attachment; filename=fleet_{metric}_{period}.csv'}
+ )
+
+
+@fleet_monitor_bp.route('/export/json', methods=['GET'])
+@jwt_required()
+def export_json():
+ """Export metrics as JSON."""
+ ids_param = request.args.get('ids', '')
+ server_ids = [s.strip() for s in ids_param.split(',') if s.strip()]
+ metric = request.args.get('metric', 'cpu')
+ period = request.args.get('period', '24h')
+
+ if not server_ids:
+ return jsonify({'error': 'ids parameter is required'}), 400
+
+ return jsonify(fleet_monitor_service.get_comparison_timeseries(server_ids, metric, period))
+
+
+# ==================== Prometheus ====================
+
+@fleet_monitor_bp.route('/prometheus', methods=['GET'])
+def prometheus_metrics():
+ """Prometheus-compatible metrics endpoint (no JWT, uses token param)."""
+ token = request.args.get('token') or request.headers.get('X-Prometheus-Token')
+ expected = os.environ.get('PROMETHEUS_TOKEN')
+
- if expected and token != expected:
++ if not expected or token != expected:
+ return Response('Unauthorized', status=401)
+
+ metrics = fleet_monitor_service.get_prometheus_metrics()
+ return Response(metrics, mimetype='text/plain; version=0.0.4; charset=utf-8')
diff --cc backend/app/api/marketplace.py
index 5ea730f7,00000000..c40fd5a8
mode 100644,000000..100644
--- a/backend/app/api/marketplace.py
+++ b/backend/app/api/marketplace.py
@@@ -1,135 -1,0 +1,141 @@@
+from flask import Blueprint, request, jsonify
+from flask_jwt_extended import jwt_required
+from app.services.marketplace_service import MarketplaceService
+
+marketplace_bp = Blueprint('marketplace', __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())
+
+
+@marketplace_bp.route('/', methods=['GET'])
+@jwt_required()
+def list_extensions():
+ category = request.args.get('category')
+ search = request.args.get('search')
+ extensions = MarketplaceService.list_extensions(category=category, search=search)
+ return jsonify({'extensions': [e.to_dict() for e in extensions]})
+
+
+@marketplace_bp.route('/categories', methods=['GET'])
+@jwt_required()
+def get_categories():
+ return jsonify({'categories': MarketplaceService.get_categories()})
+
+
+@marketplace_bp.route('/<int:ext_id>', methods=['GET'])
+@jwt_required()
+def get_extension(ext_id):
+ ext = MarketplaceService.get_extension(ext_id)
+ if not ext:
+ return jsonify({'error': 'Not found'}), 404
+ return jsonify(ext.to_dict())
+
+
+@marketplace_bp.route('/', methods=['POST'])
+@jwt_required()
+def create_extension():
+ user = get_current_user()
+ data = request.get_json()
+ if not data or 'name' not in data:
+ return jsonify({'error': 'name required'}), 400
+ try:
+ ext = MarketplaceService.create_extension(data, user.id)
+ return jsonify(ext.to_dict()), 201
+ except ValueError as e:
+ return jsonify({'error': str(e)}), 400
+
+
+@marketplace_bp.route('/<int:ext_id>', methods=['PUT'])
+@jwt_required()
+def update_extension(ext_id):
++ user = get_current_user()
++ if not user or not user.is_admin:
++ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json()
+ ext = MarketplaceService.update_extension(ext_id, data)
+ if not ext:
+ return jsonify({'error': 'Not found'}), 404
+ return jsonify(ext.to_dict())
+
+
+@marketplace_bp.route('/<int:ext_id>/publish', methods=['POST'])
+@jwt_required()
+def publish_extension(ext_id):
+ user = get_current_user()
+ if not user or not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ ext = MarketplaceService.publish_extension(ext_id)
+ if not ext:
+ return jsonify({'error': 'Not found'}), 404
+ return jsonify(ext.to_dict())
+
+
+@marketplace_bp.route('/<int:ext_id>', methods=['DELETE'])
+@jwt_required()
+def delete_extension(ext_id):
+ user = get_current_user()
+ if not user or not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ if not MarketplaceService.delete_extension(ext_id):
+ return jsonify({'error': 'Not found'}), 404
+ return jsonify({'message': 'Extension deleted'})
+
+
+# --- Installation ---
+
+@marketplace_bp.route('/<int:ext_id>/install', methods=['POST'])
+@jwt_required()
+def install_extension(ext_id):
+ user = get_current_user()
+ data = request.get_json() or {}
+ try:
+ install = MarketplaceService.install_extension(ext_id, user.id, data.get('config'))
+ return jsonify(install.to_dict()), 201
+ except ValueError as e:
+ return jsonify({'error': str(e)}), 400
+
+
+@marketplace_bp.route('/installs/<int:install_id>', methods=['DELETE'])
+@jwt_required()
+def uninstall_extension(install_id):
++ user = get_current_user()
++ if not user or not user.is_admin:
++ return jsonify({'error': 'Admin access required'}), 403
+ if not MarketplaceService.uninstall_extension(install_id):
+ return jsonify({'error': 'Not found'}), 404
+ return jsonify({'message': 'Extension uninstalled'})
+
+
+@marketplace_bp.route('/installs/<int:install_id>/config', methods=['PUT'])
+@jwt_required()
+def update_config(install_id):
+ data = request.get_json() or {}
+ install = MarketplaceService.update_extension_config(install_id, data.get('config', {}))
+ if not install:
+ return jsonify({'error': 'Not found'}), 404
+ return jsonify(install.to_dict())
+
+
+@marketplace_bp.route('/my-extensions', methods=['GET'])
+@jwt_required()
+def my_extensions():
+ user = get_current_user()
+ installs = MarketplaceService.get_user_extensions(user.id)
+ return jsonify({'extensions': [i.to_dict() for i in installs]})
+
+
+@marketplace_bp.route('/<int:ext_id>/rate', methods=['POST'])
+@jwt_required()
+def rate_extension(ext_id):
+ data = request.get_json() or {}
+ rating = data.get('rating')
+ if rating is None or not (1 <= rating <= 5):
+ return jsonify({'error': 'Rating must be 1-5'}), 400
+ ext = MarketplaceService.rate_extension(ext_id, rating)
+ if not ext:
+ return jsonify({'error': 'Not found'}), 404
+ return jsonify(ext.to_dict())
diff --cc backend/app/api/mobile.py
index 38c990b6,00000000..92e050c5
mode 100644,000000..100644
--- a/backend/app/api/mobile.py
+++ b/backend/app/api/mobile.py
@@@ -1,118 -1,0 +1,122 @@@
+from flask import Blueprint, request, jsonify
+from flask_jwt_extended import jwt_required, get_jwt_identity
+from app.models.user import User
++from app import db
+
+mobile_bp = Blueprint('mobile', __name__)
+
+
+@mobile_bp.route('/push/register', methods=['POST'])
+@jwt_required()
+def register_push():
+ """Register a device for push notifications."""
+ user_id = get_jwt_identity()
+ data = request.get_json() or {}
+ subscription = data.get('subscription')
+ device_name = data.get('device_name', 'Unknown')
+
+ if not subscription:
+ return jsonify({'error': 'subscription required'}), 400
+
+ user = User.query.get(user_id)
+ if not user:
+ return jsonify({'error': 'User not found'}), 404
+
+ # Store push subscription in user metadata
+ import json
+ push_subs = json.loads(user.push_subscriptions_json) if hasattr(user, 'push_subscriptions_json') and user.push_subscriptions_json else []
+ # Avoid duplicates
+ existing = next((s for s in push_subs if s.get('endpoint') == subscription.get('endpoint')), None)
+ if not existing:
+ push_subs.append({
+ 'subscription': subscription,
+ 'device_name': device_name,
+ 'registered_at': __import__('datetime').datetime.utcnow().isoformat(),
+ })
+
++ user.push_subscriptions_json = json.dumps(push_subs)
++ db.session.commit()
++
+ return jsonify({'message': 'Device registered', 'device_count': len(push_subs)})
+
+
+@mobile_bp.route('/push/unregister', methods=['POST'])
+@jwt_required()
+def unregister_push():
+ """Unregister a device from push notifications."""
+ data = request.get_json() or {}
+ endpoint = data.get('endpoint')
+ if not endpoint:
+ return jsonify({'error': 'endpoint required'}), 400
+ return jsonify({'message': 'Device unregistered'})
+
+
+@mobile_bp.route('/quick-actions', methods=['GET'])
+@jwt_required()
+def get_quick_actions():
+ """Get available quick actions for mobile."""
+ return jsonify({'actions': [
+ {'id': 'restart_service', 'label': 'Restart Service', 'icon': 'refresh', 'params': ['service_name']},
+ {'id': 'view_stats', 'label': 'View Server Stats', 'icon': 'chart', 'params': []},
+ {'id': 'acknowledge_alert', 'label': 'Acknowledge Alert', 'icon': 'check', 'params': ['alert_id']},
+ {'id': 'run_backup', 'label': 'Run Backup', 'icon': 'download', 'params': ['backup_id']},
+ {'id': 'toggle_maintenance', 'label': 'Toggle Maintenance', 'icon': 'wrench', 'params': ['component_id']},
+ ]})
+
+
+@mobile_bp.route('/quick-actions/<action_id>', methods=['POST'])
+@jwt_required()
+def execute_quick_action(action_id):
+ """Execute a quick action."""
+ data = request.get_json() or {}
+
+ if action_id == 'view_stats':
+ from app.services.server_metrics_service import ServerMetricsService
+ metrics = ServerMetricsService.get_current_metrics()
+ return jsonify({'action': 'view_stats', 'result': metrics})
+
+ elif action_id == 'acknowledge_alert':
+ alert_id = data.get('alert_id')
+ return jsonify({'action': 'acknowledge_alert', 'alert_id': alert_id, 'acknowledged': True})
+
+ return jsonify({'action': action_id, 'status': 'executed'})
+
+
+@mobile_bp.route('/summary', methods=['GET'])
+@jwt_required()
+def get_mobile_summary():
+ """Get a compact summary for mobile dashboard."""
+ try:
+ from app.services.server_metrics_service import ServerMetricsService
+ metrics = ServerMetricsService.get_current_metrics()
+ except Exception:
+ metrics = {}
+
+ from app.models.server import Server
+ from app.models.security_alert import SecurityAlert
+
+ server_count = Server.query.count()
+ active_alerts = SecurityAlert.query.filter_by(resolved=False).count() if hasattr(SecurityAlert, 'resolved') else 0
+
+ return jsonify({
+ 'metrics': {
+ 'cpu': metrics.get('cpu_percent', 0),
+ 'memory': metrics.get('memory_percent', 0),
+ 'disk': metrics.get('disk_percent', 0),
+ },
+ 'servers': server_count,
+ 'active_alerts': active_alerts,
+ })
+
+
+@mobile_bp.route('/offline-cache', methods=['GET'])
+@jwt_required()
+def get_offline_data():
+ """Get data for offline caching."""
+ from app.models.server import Server
+
+ servers = Server.query.limit(50).all()
+ return jsonify({
+ 'servers': [{'id': s.id, 'name': s.name, 'hostname': s.hostname, 'status': s.status} for s in servers],
+ 'cached_at': __import__('datetime').datetime.utcnow().isoformat(),
+ })
diff --cc backend/app/api/workspaces.py
index 9c5a1d57,00000000..fcc55a56
mode 100644,000000..100644
--- a/backend/app/api/workspaces.py
+++ b/backend/app/api/workspaces.py
@@@ -1,195 -1,0 +1,220 @@@
+from flask import Blueprint, request, jsonify
+from flask_jwt_extended import jwt_required
+from app.services.workspace_service import WorkspaceService
+from app.services.audit_service import AuditService
+from app.models.audit_log import AuditLog
+
+workspaces_bp = Blueprint('workspaces', __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())
+
+
++def require_workspace_access(workspace_id, user):
++ """Return 403 response tuple if user is not a workspace member or admin, else None."""
++ if user.is_admin:
++ return None
++ role = WorkspaceService.get_user_role(workspace_id, user.id)
++ if role is None:
++ return jsonify({'error': 'Workspace access denied'}), 403
++ return None
++
++
+@workspaces_bp.route('/', methods=['GET'])
+@jwt_required()
+def list_workspaces():
+ user = get_current_user()
+ include_archived = request.args.get('include_archived', 'false') == 'true'
+ # Super-admins see all, others see their memberships
+ if user.is_admin and request.args.get('all') == 'true':
+ workspaces = WorkspaceService.get_all_workspaces_admin()
+ return jsonify({'workspaces': workspaces})
+ workspaces = WorkspaceService.list_workspaces(user_id=user.id, include_archived=include_archived)
+ return jsonify({'workspaces': [ws.to_dict() for ws in workspaces]})
+
+
+@workspaces_bp.route('/<int:workspace_id>', methods=['GET'])
+@jwt_required()
+def get_workspace(workspace_id):
++ user = get_current_user()
++ denied = require_workspace_access(workspace_id, user)
++ if denied:
++ return denied
+ ws = WorkspaceService.get_workspace(workspace_id)
+ if not ws:
+ return jsonify({'error': 'Workspace not found'}), 404
+ return jsonify(ws.to_dict())
+
+
+@workspaces_bp.route('/', methods=['POST'])
+@jwt_required()
+def create_workspace():
+ user = get_current_user()
+ data = request.get_json()
+ if not data:
+ return jsonify({'error': 'Request body required'}), 400
+ try:
+ ws = WorkspaceService.create_workspace(data, user.id)
+ AuditService.log(
+ action=AuditLog.ACTION_RESOURCE_CREATE, user_id=user.id,
+ target_type='workspace', target_id=ws.id,
+ details={'name': ws.name}
+ )
+ return jsonify(ws.to_dict()), 201
+ except ValueError as e:
+ return jsonify({'error': str(e)}), 400
+
+
+@workspaces_bp.route('/<int:workspace_id>', methods=['PUT'])
+@jwt_required()
+def update_workspace(workspace_id):
+ user = get_current_user()
+ role = WorkspaceService.get_user_role(workspace_id, user.id)
+ if role not in ['owner', 'admin'] and not user.is_admin:
+ return jsonify({'error': 'Insufficient permissions'}), 403
+
+ data = request.get_json()
+ ws = WorkspaceService.update_workspace(workspace_id, data)
+ if not ws:
+ return jsonify({'error': 'Workspace not found'}), 404
+ return jsonify(ws.to_dict())
+
+
+@workspaces_bp.route('/<int:workspace_id>/archive', methods=['POST'])
+@jwt_required()
+def archive_workspace(workspace_id):
+ user = get_current_user()
+ role = WorkspaceService.get_user_role(workspace_id, user.id)
+ if role != 'owner' and not user.is_admin:
+ return jsonify({'error': 'Owner access required'}), 403
+ ws = WorkspaceService.archive_workspace(workspace_id)
+ if not ws:
+ return jsonify({'error': 'Workspace not found'}), 404
+ return jsonify(ws.to_dict())
+
+
+@workspaces_bp.route('/<int:workspace_id>/restore', methods=['POST'])
+@jwt_required()
+def restore_workspace(workspace_id):
+ user = get_current_user()
+ if not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ ws = WorkspaceService.restore_workspace(workspace_id)
+ if not ws:
+ return jsonify({'error': 'Workspace not found'}), 404
+ return jsonify(ws.to_dict())
+
+
+@workspaces_bp.route('/<int:workspace_id>', methods=['DELETE'])
+@jwt_required()
+def delete_workspace(workspace_id):
+ user = get_current_user()
+ if not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ result = WorkspaceService.delete_workspace(workspace_id)
+ if not result:
+ return jsonify({'error': 'Workspace not found'}), 404
+ return jsonify({'message': 'Workspace deleted'})
+
+
+# --- Members ---
+
+@workspaces_bp.route('/<int:workspace_id>/members', methods=['GET'])
+@jwt_required()
+def get_members(workspace_id):
++ user = get_current_user()
++ denied = require_workspace_access(workspace_id, user)
++ if denied:
++ return denied
+ members = WorkspaceService.get_members(workspace_id)
+ return jsonify({'members': [m.to_dict() for m in members]})
+
+
+@workspaces_bp.route('/<int:workspace_id>/members', methods=['POST'])
+@jwt_required()
+def add_member(workspace_id):
+ user = get_current_user()
+ role = WorkspaceService.get_user_role(workspace_id, user.id)
+ if role not in ['owner', 'admin'] and not user.is_admin:
+ return jsonify({'error': 'Insufficient permissions'}), 403
+
+ data = request.get_json() or {}
+ user_id = data.get('user_id')
+ if not user_id:
+ return jsonify({'error': 'user_id required'}), 400
+
+ try:
+ member = WorkspaceService.add_member(workspace_id, user_id, data.get('role', 'member'))
+ return jsonify(member.to_dict()), 201
+ except ValueError as e:
+ return jsonify({'error': str(e)}), 400
+
+
+@workspaces_bp.route('/members/<int:member_id>/role', methods=['PUT'])
+@jwt_required()
+def update_member_role(member_id):
+ data = request.get_json() or {}
+ role = data.get('role')
+ if not role:
+ return jsonify({'error': 'role required'}), 400
+ member = WorkspaceService.update_member_role(member_id, role)
+ if not member:
+ return jsonify({'error': 'Member not found'}), 404
+ return jsonify(member.to_dict())
+
+
+@workspaces_bp.route('/members/<int:member_id>', methods=['DELETE'])
+@jwt_required()
+def remove_member(member_id):
+ try:
+ result = WorkspaceService.remove_member(member_id)
+ if not result:
+ return jsonify({'error': 'Member not found'}), 404
+ return jsonify({'message': 'Member removed'})
+ except ValueError as e:
+ return jsonify({'error': str(e)}), 400
+
+
+# --- API Keys ---
+
+@workspaces_bp.route('/<int:workspace_id>/api-keys', methods=['GET'])
+@jwt_required()
+def list_api_keys(workspace_id):
++ user = get_current_user()
++ denied = require_workspace_access(workspace_id, user)
++ if denied:
++ return denied
+ keys = WorkspaceService.list_api_keys(workspace_id)
+ return jsonify({'api_keys': [k.to_dict() for k in keys]})
+
+
+@workspaces_bp.route('/<int:workspace_id>/api-keys', methods=['POST'])
+@jwt_required()
+def create_api_key(workspace_id):
+ user = get_current_user()
++ denied = require_workspace_access(workspace_id, user)
++ if denied:
++ return denied
+ data = request.get_json() or {}
+ name = data.get('name')
+ if not name:
+ return jsonify({'error': 'name required'}), 400
+
+ api_key, raw_key = WorkspaceService.create_api_key(
+ workspace_id, name, scopes=data.get('scopes'), user_id=user.id
+ )
+ result = api_key.to_dict()
+ result['key'] = raw_key # Only returned once
+ return jsonify(result), 201
+
+
+@workspaces_bp.route('/api-keys/<int:key_id>/revoke', methods=['POST'])
+@jwt_required()
+def revoke_api_key(key_id):
+ result = WorkspaceService.revoke_api_key(key_id)
+ if not result:
+ return jsonify({'error': 'API key not found'}), 404
+ return jsonify({'message': 'API key revoked'})
diff --cc backend/app/services/agent_registry.py
index e3cde688,db298454..0118aa56
--- a/backend/app/services/agent_registry.py
+++ b/backend/app/services/agent_registry.py
@@@ -123,7 -120,7 +123,7 @@@ class AgentRegistry
self._handle_agent_timeout(server_id)
except Exception as e:
-- print(f"Error in heartbeat checker: {e}")
++ logger.error("Error in heartbeat checker: %s", e)
self._stop_heartbeat.wait(30) # Check every 30 seconds
@@@ -155,7 -152,7 +155,7 @@@
session.disconnect_reason = 'heartbeat_timeout'
db.session.commit()
except Exception as e:
-- print(f"Error updating server status: {e}")
++ logger.exception("Error updating server status")
# ==================== Connection Management ====================
@@@ -214,16 -211,8 +214,16 @@@
)
db.session.add(session)
db.session.commit()
+
+ # Deliver any queued commands for this server
+ try:
+ from app.services.agent_fleet_service import fleet_service
+ fleet_service.deliver_queued_commands(server_id)
+ except Exception as e:
- print(f"Error delivering queued commands: {e}")
++ logger.error("Error delivering queued commands: %s", e)
+
except Exception as e:
-- print(f"Error registering agent: {e}")
++ logger.exception("Error registering agent")
db.session.rollback()
return session_token
@@@ -255,7 -244,7 +255,7 @@@
session.disconnect_reason = reason
db.session.commit()
except Exception as e:
-- print(f"Error unregistering agent: {e}")
++ logger.exception("Error unregistering agent")
db.session.rollback()
def get_agent(self, server_id: str) -> Optional[ConnectedAgent]:
@@@ -320,7 -292,7 +320,7 @@@
if metrics:
self._store_metrics(server_id, metrics)
except Exception as e:
-- print(f"Error updating heartbeat: {e}")
++ logger.exception("Error updating heartbeat")
db.session.rollback()
def _store_metrics(self, server_id: str, metrics: dict):
@@@ -337,7 -309,7 +337,7 @@@
db.session.add(metric)
db.session.commit()
except Exception as e:
-- print(f"Error storing metrics: {e}")
++ logger.exception("Error storing metrics")
db.session.rollback()
# ==================== Command Routing ====================
@@@ -612,7 -572,7 +612,7 @@@
server.agent_version = info.get('agent_version', server.agent_version)
db.session.commit()
except Exception as e:
-- print(f"Error updating system info: {e}")
++ logger.exception("Error updating system info")
db.session.rollback()
diff --cc backend/app/services/monitoring_service.py
index 44beae86,57fd9a18..5a781230
--- a/backend/app/services/monitoring_service.py
+++ b/backend/app/services/monitoring_service.py
@@@ -1,5 -1,5 +1,6 @@@
import os
import json
++import logging
import psutil
import smtplib
from email.mime.text import MIMEText
@@@ -10,6 -10,6 +11,8 @@@ from pathlib import Pat
import threading
import time
++logger = logging.getLogger(__name__)
++
from .notification_service import NotificationService
from app import paths
@@@ -280,25 -280,6 +283,25 @@@ class MonitoringService
# Send to all configured notification channels (Discord, Slack, Telegram, etc.)
NotificationService.send_all(alerts_to_send)
+ # Emit events for workflow triggers
+ try:
+ from app.services.workflow_engine import WorkflowEventBus
+ for alert in alerts_to_send:
+ if alert['type'] == 'cpu':
+ WorkflowEventBus.emit('high_cpu', {
+ 'percent': alert.get('value'),
+ 'threshold': alert.get('threshold'),
+ 'severity': alert.get('severity')
+ })
+ elif alert['type'] == 'memory':
+ WorkflowEventBus.emit('high_memory', {
+ 'percent': alert.get('value'),
+ 'threshold': alert.get('threshold'),
+ 'severity': alert.get('severity')
+ })
+ except Exception:
- pass
++ logger.exception("Error emitting workflow events for alerts")
+
@classmethod
def log_alert(cls, alerts: List[Dict]) -> None:
"""Log alerts to file."""
diff --cc frontend/package.json
index 89713e8f,4bffede5..31f83ab4
--- a/frontend/package.json
+++ b/frontend/package.json
@@@ -9,8 -9,7 +9,10 @@@
"lint": "eslint .",
"preview": "vite preview"
},
++ "optionalDependencies": {
++ "@rollup/rollup-win32-x64-msvc": "^4.60.0"
++ },
"dependencies": {
- "@rollup/rollup-win32-x64-msvc": "^4.60.0",
"@xterm/addon-fit": "^0.10.0",
"@xterm/addon-web-links": "^0.11.0",
"@xterm/xterm": "^5.5.0",
diff --cc frontend/src/components/Modal.jsx
index d663fb3b,00000000..3fc20ca3
mode 100644,000000..100644
--- a/frontend/src/components/Modal.jsx
+++ b/frontend/src/components/Modal.jsx
@@@ -1,46 -1,0 +1,51 @@@
+import { useEffect, useRef } from 'react';
+
- export default function Modal({ open, onClose, title, children, className = '', size = '' }) {
++export default function Modal({ open, onClose, title, children, footer, className = '', size = '' }) {
+ const modalRef = useRef(null);
+
+ // Close on Escape key
+ useEffect(() => {
+ if (!open) return;
+ const handleKeyDown = (e) => {
+ if (e.key === 'Escape') onClose();
+ };
+ document.addEventListener('keydown', handleKeyDown);
+ return () => document.removeEventListener('keydown', handleKeyDown);
+ }, [open, onClose]);
+
+ // Focus trap: focus the modal when it opens
+ useEffect(() => {
+ if (open && modalRef.current) {
+ modalRef.current.focus();
+ }
+ }, [open]);
+
+ if (!open) return null;
+
+ return (
+ <div className="modal-overlay" onClick={onClose}>
+ <div
+ className={`modal ${size ? `modal-${size}` : ''} ${className}`.trim()}
+ onClick={e => e.stopPropagation()}
+ ref={modalRef}
+ tabIndex={-1}
+ role="dialog"
+ aria-modal="true"
+ aria-label={title}
+ >
+ <div className="modal-header">
+ <h3>{title}</h3>
+ <button className="modal-close" onClick={onClose} aria-label="Close">&times;</button>
+ </div>
+ <div className="modal-body">
+ {children}
+ </div>
++ {footer && (
++ <div className="modal-footer">
++ {footer}
++ </div>
++ )}
+ </div>
+ </div>
+ );
+}
diff --cc frontend/src/pages/DNSZones.jsx
index 4b60adf5,00000000..cebaae99
mode 100644,000000..100644
--- a/frontend/src/pages/DNSZones.jsx
+++ b/frontend/src/pages/DNSZones.jsx
@@@ -1,316 -1,0 +1,336 @@@
+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 [zoneForm, setZoneForm] = useState({ domain: '', provider: 'manual', provider_zone_id: '', api_token: '' });
+ 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);
++ const payload = {
++ domain: zoneForm.domain,
++ provider: zoneForm.provider,
++ };
++ if (zoneForm.provider !== 'manual') {
++ payload.provider_zone_id = zoneForm.provider_zone_id;
++ payload.provider_config = { api_token: zoneForm.api_token };
++ }
++ await api.createDNSZone(payload);
+ toast.success('Zone created');
+ setShowCreateZone(false);
- setZoneForm({ domain: '', provider: 'manual' });
++ setZoneForm({ domain: '', provider: 'manual', provider_zone_id: '', api_token: '' });
+ 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)}>&times;</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>
++ {zoneForm.provider !== 'manual' && (
++ <>
++ <div className="form-group">
++ <label>Zone ID</label>
++ <input className="form-input" value={zoneForm.provider_zone_id} onChange={e => setZoneForm({...zoneForm, provider_zone_id: e.target.value})} placeholder={zoneForm.provider === 'cloudflare' ? 'Cloudflare Zone ID' : 'Provider Zone ID'} />
++ </div>
++ <div className="form-group">
++ <label>API Token</label>
++ <input className="form-input" type="password" value={zoneForm.api_token} onChange={e => setZoneForm({...zoneForm, api_token: e.target.value})} placeholder={`${zoneForm.provider.charAt(0).toUpperCase() + zoneForm.provider.slice(1)} API token`} />
++ </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)}>&times;</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)}>&times;</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 --cc frontend/src/services/api/dns.js
index 00000000,00000000..6ff7ef54
new file mode 100644
--- /dev/null
+++ b/frontend/src/services/api/dns.js
@@@ -1,0 -1,0 +1,59 @@@
++// DNS Zones & Records
++
++export async function getDNSZones() {
++ return this.request('/dns/');
++}
++
++export async function getDNSZone(zoneId) {
++ return this.request(`/dns/${zoneId}`);
++}
++
++export async function createDNSZone(data) {
++ return this.request('/dns/', { method: 'POST', body: data });
++}
++
++export async function deleteDNSZone(zoneId) {
++ return this.request(`/dns/${zoneId}`, { method: 'DELETE' });
++}
++
++export async function getDNSRecords(zoneId) {
++ return this.request(`/dns/${zoneId}/records`);
++}
++
++export async function createDNSRecord(zoneId, data) {
++ return this.request(`/dns/${zoneId}/records`, { method: 'POST', body: data });
++}
++
++export async function updateDNSRecord(recordId, data) {
++ return this.request(`/dns/records/${recordId}`, { method: 'PUT', body: data });
++}
++
++export async function deleteDNSRecord(recordId) {
++ return this.request(`/dns/records/${recordId}`, { method: 'DELETE' });
++}
++
++export async function getDNSPresets() {
++ return this.request('/dns/presets');
++}
++
++export async function applyDNSPreset(zoneId, preset, variables = {}) {
++ return this.request(`/dns/${zoneId}/apply-preset`, {
++ method: 'POST',
++ body: { preset, variables },
++ });
++}
++
++export async function checkDNSPropagation(domain, type = 'A') {
++ return this.request(`/dns/propagation/${domain}?type=${type}`);
++}
++
++export async function exportDNSZone(zoneId) {
++ return this.request(`/dns/${zoneId}/export`);
++}
++
++export async function importDNSZone(zoneId, zoneFile) {
++ return this.request(`/dns/${zoneId}/import`, {
++ method: 'POST',
++ body: { zone_file: zoneFile },
++ });
++}
diff --cc frontend/src/services/api/index.js
index 7be72b75,00000000..017f7a8d
mode 100644,000000..100644
--- a/frontend/src/services/api/index.js
+++ b/frontend/src/services/api/index.js
@@@ -1,38 -1,0 +1,40 @@@
+import ApiClient from './client.js';
+import * as authMethods from './auth.js';
+import * as appMethods from './apps.js';
+import * as dockerMethods from './docker.js';
+import * as databaseMethods from './databases.js';
+import * as serverMethods from './servers.js';
+import * as wordpressMethods from './wordpress.js';
+import * as systemMethods from './system.js';
+import * as securityMethods from './security.js';
+import * as fileMethods from './files.js';
++import * as dnsMethods from './dns.js';
+
+class ApiService extends ApiClient {
+ constructor() {
+ super();
+ // Bind all methods from domain modules to this instance
+ const modules = [
+ authMethods,
+ appMethods,
+ dockerMethods,
+ databaseMethods,
+ serverMethods,
+ wordpressMethods,
+ systemMethods,
+ securityMethods,
+ fileMethods,
++ dnsMethods,
+ ];
+ for (const mod of modules) {
+ for (const [key, fn] of Object.entries(mod)) {
+ if (typeof fn === 'function') {
+ this[key] = fn.bind(this);
+ }
+ }
+ }
+ }
+}
+
+export const api = new ApiService();
+export default api;
diff --cc install.sh
index 64cf8989,7a60fb0f..4aa94a26
--- a/install.sh
+++ b/install.sh
@@@ -130,8 -79,11 +130,9 @@@ if [ "$OS_FAMILY" = "debian" ] || [ "$O
sed -i "s/#\$nrconf{restart} = 'i';/\$nrconf{restart} = 'a';/" /etc/needrestart/needrestart.conf 2>/dev/null || true
fi
- # Update package list
apt-get update
- # Install Python and required packages
++
apt-get install -y \
python3 \
python3-pip \