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 multi-server management and agent gateway

Juan Denis009fb1243500
diff --git a/backend/app/__init__.py b/backend/app/__init__.py
index 0903bbe0..959abd36 100644
--- a/backend/app/__init__.py
+++ b/backend/app/__init__.py
@@ -51,6 +51,10 @@ def create_app(config_name=None):
from app.sockets import init_socketio
socketio = init_socketio(app)
+ # Initialize Agent Gateway
+ from app.agent_gateway import init_agent_gateway
+ init_agent_gateway(socketio)
+
# Register blueprints - Auth
from app.api.auth import auth_bp
app.register_blueprint(auth_bp, url_prefix='/api/v1/auth')
@@ -167,6 +171,10 @@ def create_app(config_name=None):
from app.api.workflows import workflows_bp
app.register_blueprint(workflows_bp, url_prefix='/api/v1/workflows')
+ # Register blueprints - Servers (Multi-server management)
+ from app.api.servers import servers_bp
+ app.register_blueprint(servers_bp, url_prefix='/api/v1/servers')
+
# Create database tables
with app.app_context():
db.create_all()
diff --git a/backend/app/agent_gateway.py b/backend/app/agent_gateway.py
new file mode 100644
index 00000000..1a684522
--- /dev/null
+++ b/backend/app/agent_gateway.py
@@ -0,0 +1,246 @@
+"""
+Agent Gateway
+
+WebSocket gateway for ServerKit agents.
+Handles agent connections, authentication, and message routing.
+"""
+
+from flask import request
+from flask_socketio import Namespace, emit, disconnect
+import json
+import time
+
+from app.services.agent_registry import agent_registry
+from app.models.server import Server
+
+
+class AgentNamespace(Namespace):
+ """
+ SocketIO namespace for agent connections.
+
+ Agents connect to: /agent
+ """
+
+ def on_connect(self):
+ """Handle agent connection attempt"""
+ # Connection is not authenticated yet
+ # Agent must send auth message first
+ print(f"[AgentGateway] New connection from {request.remote_addr}")
+
+ def on_disconnect(self):
+ """Handle agent disconnection"""
+ sid = request.sid
+ print(f"[AgentGateway] Disconnect: {sid}")
+ agent_registry.unregister_agent(sid, reason='disconnect')
+
+ def on_auth(self, data):
+ """
+ Handle agent authentication.
+
+ Expected data:
+ {
+ "type": "auth",
+ "agent_id": "uuid",
+ "api_key_prefix": "sk_xxx",
+ "signature": "hmac_signature",
+ "timestamp": unix_ms
+ }
+ """
+ sid = request.sid
+ agent_id = data.get('agent_id')
+ api_key_prefix = data.get('api_key_prefix')
+ signature = data.get('signature')
+ timestamp = data.get('timestamp', 0)
+
+ print(f"[AgentGateway] Auth attempt from agent {agent_id}")
+
+ if not all([agent_id, api_key_prefix, signature]):
+ emit('auth_fail', {
+ 'type': 'auth_fail',
+ 'error': 'Missing required fields'
+ })
+ disconnect()
+ return
+
+ # Verify authentication
+ server = agent_registry.verify_agent_auth(
+ agent_id, api_key_prefix, signature, timestamp
+ )
+
+ if not server:
+ emit('auth_fail', {
+ 'type': 'auth_fail',
+ 'error': 'Authentication failed'
+ })
+ disconnect()
+ return
+
+ # Register agent
+ ip_address = request.remote_addr
+ agent_version = request.headers.get('User-Agent', '').replace('ServerKit-Agent/', '')
+
+ session_token = agent_registry.register_agent(
+ server_id=server.id,
+ socket_id=sid,
+ ip_address=ip_address,
+ agent_version=agent_version
+ )
+
+ # Calculate token expiry (1 hour)
+ expires = int((time.time() + 3600) * 1000)
+
+ emit('auth_ok', {
+ 'type': 'auth_ok',
+ 'session_token': session_token,
+ 'expires': expires,
+ 'server_id': server.id
+ })
+
+ print(f"[AgentGateway] Agent {agent_id} authenticated successfully")
+
+ def on_heartbeat(self, data):
+ """
+ Handle agent heartbeat.
+
+ Expected data:
+ {
+ "type": "heartbeat",
+ "metrics": {
+ "cpu_percent": float,
+ "memory_percent": float,
+ "disk_percent": float,
+ "container_count": int,
+ "container_running": int
+ }
+ }
+ """
+ sid = request.sid
+ agent = agent_registry.get_agent_by_socket(sid)
+
+ if not agent:
+ emit('error', {
+ 'type': 'error',
+ 'code': 'NOT_AUTHENTICATED',
+ 'message': 'Not authenticated'
+ })
+ return
+
+ metrics = data.get('metrics', {})
+ agent_registry.update_heartbeat(agent.server_id, metrics)
+
+ emit('heartbeat_ack', {'type': 'heartbeat_ack'})
+
+ def on_command_result(self, data):
+ """
+ Handle command result from agent.
+
+ Expected data:
+ {
+ "type": "command_result",
+ "command_id": "uuid",
+ "success": bool,
+ "data": any,
+ "error": string,
+ "duration": int (ms)
+ }
+ """
+ sid = request.sid
+ agent_registry.handle_command_result(sid, data)
+
+ def on_system_info(self, data):
+ """
+ Handle system info update from agent.
+
+ Expected data:
+ {
+ "type": "system_info",
+ "info": {
+ "hostname": string,
+ "os": string,
+ "os_version": string,
+ "platform": string,
+ "architecture": string,
+ "cpu_cores": int,
+ "cpu_model": string,
+ "total_memory": int,
+ "total_disk": int,
+ "docker_version": string,
+ "agent_version": string
+ }
+ }
+ """
+ sid = request.sid
+ agent = agent_registry.get_agent_by_socket(sid)
+
+ if not agent:
+ emit('error', {
+ 'type': 'error',
+ 'code': 'NOT_AUTHENTICATED',
+ 'message': 'Not authenticated'
+ })
+ return
+
+ info = data.get('info', {})
+ agent_registry.update_system_info(agent.server_id, info)
+
+ def on_stream(self, data):
+ """
+ Handle streaming data from agent (logs, metrics).
+
+ Expected data:
+ {
+ "type": "stream",
+ "channel": string,
+ "data": any
+ }
+ """
+ sid = request.sid
+ agent = agent_registry.get_agent_by_socket(sid)
+
+ if not agent:
+ return
+
+ channel = data.get('channel')
+ stream_data = data.get('data')
+
+ # Broadcast to subscribers
+ # The channel format determines where to broadcast:
+ # - "metrics" -> room: f"server_{server_id}_metrics"
+ # - "container:xxx:logs" -> room: f"server_{server_id}_container_logs"
+
+ if channel == 'metrics':
+ room = f"server_{agent.server_id}_metrics"
+ elif channel.startswith('container:') and channel.endswith(':logs'):
+ container_id = channel.split(':')[1]
+ room = f"server_{agent.server_id}_container_{container_id}_logs"
+ else:
+ room = f"server_{agent.server_id}_{channel}"
+
+ # Emit to the main namespace for UI clients
+ from app import get_socketio
+ socketio = get_socketio()
+ if socketio:
+ socketio.emit(
+ 'server_stream',
+ {
+ 'server_id': agent.server_id,
+ 'channel': channel,
+ 'data': stream_data
+ },
+ room=room
+ )
+
+ def on_error(self, data):
+ """Handle error message from agent"""
+ sid = request.sid
+ agent = agent_registry.get_agent_by_socket(sid)
+
+ if agent:
+ print(f"[AgentGateway] Error from server {agent.server_id}: {data}")
+
+
+def init_agent_gateway(socketio):
+ """Initialize the agent gateway namespace"""
+ agent_registry.init_socketio(socketio)
+ socketio.on_namespace(AgentNamespace('/agent'))
+ print("[AgentGateway] Agent gateway initialized on /agent namespace")
diff --git a/backend/app/api/servers.py b/backend/app/api/servers.py
new file mode 100644
index 00000000..e25b35fb
--- /dev/null
+++ b/backend/app/api/servers.py
@@ -0,0 +1,835 @@
+"""
+Server Management API
+
+Endpoints for managing remote servers and their agents.
+"""
+
+from datetime import datetime, timedelta
+from flask import Blueprint, request, jsonify
+from flask_jwt_extended import jwt_required, get_jwt_identity
+
+from app import db
+from app.models import User
+from app.models.server import Server, ServerGroup, ServerMetrics, ServerCommand, AgentSession
+from app.services.agent_registry import agent_registry
+from app.middleware.rbac import admin_required, developer_required
+
+servers_bp = Blueprint('servers', __name__)
+
+
+# ==================== Permission Profiles ====================
+
+PERMISSION_PROFILES = {
+ 'docker_readonly': {
+ 'name': 'Docker Read-Only',
+ 'description': 'View containers, images, and metrics',
+ 'permissions': [
+ 'docker:container:read',
+ 'docker:image:read',
+ 'docker:compose:read',
+ 'docker:volume:read',
+ 'docker:network:read',
+ 'system:metrics:read',
+ ]
+ },
+ 'docker_manager': {
+ 'name': 'Docker Manager',
+ 'description': 'Full Docker management and metrics',
+ 'permissions': [
+ 'docker:container:*',
+ 'docker:image:*',
+ 'docker:compose:*',
+ 'docker:volume:*',
+ 'docker:network:*',
+ 'system:metrics:read',
+ 'system:logs:read',
+ ]
+ },
+ 'full_access': {
+ 'name': 'Full Access',
+ 'description': 'All permissions including system commands',
+ 'permissions': ['*']
+ }
+}
+
+
+# ==================== Server Groups ====================
+
+@servers_bp.route('/groups', methods=['GET'])
+@jwt_required()
+def list_groups():
+ """List all server groups"""
+ groups = ServerGroup.query.all()
+ return jsonify([g.to_dict() for g in groups])
+
+
+@servers_bp.route('/groups', methods=['POST'])
+@jwt_required()
+@developer_required
+def create_group():
+ """Create a new server group"""
+ data = request.get_json()
+
+ if not data.get('name'):
+ return jsonify({'error': 'Name is required'}), 400
+
+ group = ServerGroup(
+ name=data['name'],
+ description=data.get('description'),
+ color=data.get('color', '#6366f1'),
+ icon=data.get('icon', 'server'),
+ parent_id=data.get('parent_id')
+ )
+
+ db.session.add(group)
+ db.session.commit()
+
+ return jsonify(group.to_dict()), 201
+
+
+@servers_bp.route('/groups/<group_id>', methods=['GET'])
+@jwt_required()
+def get_group(group_id):
+ """Get a server group by ID"""
+ group = ServerGroup.query.get(group_id)
+ if not group:
+ return jsonify({'error': 'Group not found'}), 404
+
+ return jsonify(group.to_dict(include_servers=True))
+
+
+@servers_bp.route('/groups/<group_id>', methods=['PUT'])
+@jwt_required()
+@developer_required
+def update_group(group_id):
+ """Update a server group"""
+ group = ServerGroup.query.get(group_id)
+ if not group:
+ return jsonify({'error': 'Group not found'}), 404
+
+ data = request.get_json()
+
+ if 'name' in data:
+ group.name = data['name']
+ if 'description' in data:
+ group.description = data['description']
+ if 'color' in data:
+ group.color = data['color']
+ if 'icon' in data:
+ group.icon = data['icon']
+ if 'parent_id' in data:
+ group.parent_id = data['parent_id']
+
+ db.session.commit()
+ return jsonify(group.to_dict())
+
+
+@servers_bp.route('/groups/<group_id>', methods=['DELETE'])
+@jwt_required()
+@admin_required
+def delete_group(group_id):
+ """Delete a server group"""
+ group = ServerGroup.query.get(group_id)
+ if not group:
+ return jsonify({'error': 'Group not found'}), 404
+
+ # Move servers to no group
+ for server in group.servers:
+ server.group_id = None
+
+ db.session.delete(group)
+ db.session.commit()
+
+ return jsonify({'message': 'Group deleted'})
+
+
+# ==================== Servers ====================
+
+@servers_bp.route('', methods=['GET'])
+@jwt_required()
+def list_servers():
+ """List all servers"""
+ # Query parameters
+ group_id = request.args.get('group_id')
+ status = request.args.get('status')
+ tag = request.args.get('tag')
+
+ query = Server.query
+
+ if group_id:
+ query = query.filter_by(group_id=group_id)
+ if status:
+ query = query.filter_by(status=status)
+ if tag:
+ query = query.filter(Server.tags.contains([tag]))
+
+ servers = query.order_by(Server.name).all()
+
+ # Add connection status
+ result = []
+ for server in servers:
+ server_dict = server.to_dict()
+ server_dict['is_connected'] = agent_registry.is_agent_connected(server.id)
+ result.append(server_dict)
+
+ return jsonify(result)
+
+
+@servers_bp.route('', methods=['POST'])
+@jwt_required()
+@developer_required
+def create_server():
+ """
+ Create a new server and generate registration token.
+
+ Returns server info with registration token for agent installation.
+ """
+ data = request.get_json()
+ user_id = get_jwt_identity()
+
+ if not data.get('name'):
+ return jsonify({'error': 'Name is required'}), 400
+
+ # Generate registration token
+ registration_token = Server.generate_registration_token()
+
+ # Get permissions from profile or custom list
+ permissions = data.get('permissions', [])
+ profile = data.get('permission_profile')
+ if profile and profile in PERMISSION_PROFILES:
+ permissions = PERMISSION_PROFILES[profile]['permissions']
+
+ server = Server(
+ name=data['name'],
+ description=data.get('description'),
+ group_id=data.get('group_id'),
+ tags=data.get('tags', []),
+ permissions=permissions,
+ allowed_ips=data.get('allowed_ips', []),
+ registered_by=user_id,
+ registration_token_expires=datetime.utcnow() + timedelta(hours=24)
+ )
+ server.set_registration_token(registration_token)
+
+ db.session.add(server)
+ db.session.commit()
+
+ result = server.to_dict()
+ result['registration_token'] = registration_token
+ result['registration_expires'] = server.registration_token_expires.isoformat()
+
+ return jsonify(result), 201
+
+
+@servers_bp.route('/<server_id>', methods=['GET'])
+@jwt_required()
+def get_server(server_id):
+ """Get a server by ID"""
+ server = Server.query.get(server_id)
+ if not server:
+ return jsonify({'error': 'Server not found'}), 404
+
+ result = server.to_dict(include_metrics=True)
+ result['is_connected'] = agent_registry.is_agent_connected(server.id)
+
+ return jsonify(result)
+
+
+@servers_bp.route('/<server_id>', methods=['PUT'])
+@jwt_required()
+@developer_required
+def update_server(server_id):
+ """Update a server"""
+ server = Server.query.get(server_id)
+ if not server:
+ return jsonify({'error': 'Server not found'}), 404
+
+ data = request.get_json()
+
+ if 'name' in data:
+ server.name = data['name']
+ if 'description' in data:
+ server.description = data['description']
+ if 'group_id' in data:
+ server.group_id = data['group_id']
+ if 'tags' in data:
+ server.tags = data['tags']
+ if 'permissions' in data:
+ server.permissions = data['permissions']
+ if 'allowed_ips' in data:
+ server.allowed_ips = data['allowed_ips']
+
+ # Handle permission profile
+ if 'permission_profile' in data:
+ profile = data['permission_profile']
+ if profile in PERMISSION_PROFILES:
+ server.permissions = PERMISSION_PROFILES[profile]['permissions']
+
+ db.session.commit()
+ return jsonify(server.to_dict())
+
+
+@servers_bp.route('/<server_id>', methods=['DELETE'])
+@jwt_required()
+@admin_required
+def delete_server(server_id):
+ """Delete a server"""
+ server = Server.query.get(server_id)
+ if not server:
+ return jsonify({'error': 'Server not found'}), 404
+
+ # Disconnect agent if connected
+ if agent_registry.is_agent_connected(server_id):
+ # TODO: Send disconnect command to agent
+ pass
+
+ db.session.delete(server)
+ db.session.commit()
+
+ return jsonify({'message': 'Server deleted'})
+
+
+# ==================== Registration ====================
+
+@servers_bp.route('/<server_id>/regenerate-token', methods=['POST'])
+@jwt_required()
+@developer_required
+def regenerate_token(server_id):
+ """Regenerate registration token for a server"""
+ server = Server.query.get(server_id)
+ if not server:
+ return jsonify({'error': 'Server not found'}), 404
+
+ registration_token = Server.generate_registration_token()
+ server.set_registration_token(registration_token)
+ server.registration_token_expires = datetime.utcnow() + timedelta(hours=24)
+ server.status = 'pending'
+ server.agent_id = None
+
+ db.session.commit()
+
+ return jsonify({
+ 'registration_token': registration_token,
+ 'registration_expires': server.registration_token_expires.isoformat()
+ })
+
+
+@servers_bp.route('/register', methods=['POST'])
+def register_agent():
+ """
+ Agent registration endpoint.
+
+ Called by agents during initial setup.
+
+ Expected data:
+ {
+ "token": "sk_reg_xxx",
+ "name": "server-name",
+ "system_info": {...},
+ "agent_version": "1.0.0"
+ }
+ """
+ data = request.get_json()
+
+ token = data.get('token')
+ if not token:
+ return jsonify({'error': 'Registration token required'}), 400
+
+ # Find server by token (need to check all servers)
+ server = None
+ for s in Server.query.filter(Server.registration_token_hash.isnot(None)).all():
+ if s.verify_registration_token(token):
+ server = s
+ break
+
+ if not server:
+ return jsonify({'error': 'Invalid or expired registration token'}), 401
+
+ # Generate API credentials
+ api_key, api_secret = Server.generate_api_credentials()
+
+ # Update server with agent info
+ server.agent_id = data.get('agent_id') or str(__import__('uuid').uuid4())
+ server.set_api_key(api_key)
+ server.status = 'connecting'
+ server.registered_at = datetime.utcnow()
+
+ # Clear registration token (single use)
+ server.registration_token_hash = None
+ server.registration_token_expires = None
+
+ # Update system info if provided
+ system_info = data.get('system_info', {})
+ if system_info:
+ server.hostname = system_info.get('hostname', server.hostname)
+ server.os_type = system_info.get('os', server.os_type)
+ server.os_version = system_info.get('platform_version', server.os_version)
+ server.platform = system_info.get('platform', server.platform)
+ server.architecture = system_info.get('architecture', server.architecture)
+ server.cpu_cores = system_info.get('cpu_cores', server.cpu_cores)
+ server.total_memory = system_info.get('total_memory', server.total_memory)
+ server.total_disk = system_info.get('total_disk', server.total_disk)
+
+ server.agent_version = data.get('agent_version')
+
+ # Update name if provided and different
+ if data.get('name') and not server.name:
+ server.name = data['name']
+
+ db.session.commit()
+
+ # Construct WebSocket URL
+ ws_scheme = 'wss' if request.is_secure else 'ws'
+ ws_url = f"{ws_scheme}://{request.host}/agent"
+
+ return jsonify({
+ 'agent_id': server.agent_id,
+ 'name': server.name,
+ 'api_key': api_key,
+ 'api_secret': api_secret,
+ 'websocket_url': ws_url,
+ 'server_id': server.id
+ })
+
+
+# ==================== Server Status ====================
+
+@servers_bp.route('/<server_id>/status', methods=['GET'])
+@jwt_required()
+def get_server_status(server_id):
+ """Get current server status and live metrics"""
+ server = Server.query.get(server_id)
+ if not server:
+ return jsonify({'error': 'Server not found'}), 404
+
+ is_connected = agent_registry.is_agent_connected(server_id)
+
+ result = {
+ 'id': server.id,
+ 'name': server.name,
+ 'status': 'online' if is_connected else server.status,
+ 'is_connected': is_connected,
+ 'last_seen': server.last_seen.isoformat() if server.last_seen else None,
+ 'last_error': server.last_error,
+ }
+
+ # Get latest metrics
+ latest_metrics = server.metrics.order_by(ServerMetrics.timestamp.desc()).first()
+ if latest_metrics:
+ result['metrics'] = latest_metrics.to_dict()
+
+ return jsonify(result)
+
+
+@servers_bp.route('/<server_id>/ping', methods=['POST'])
+@jwt_required()
+def ping_server(server_id):
+ """Force a ping/health check on a server"""
+ server = Server.query.get(server_id)
+ if not server:
+ return jsonify({'error': 'Server not found'}), 404
+
+ if not agent_registry.is_agent_connected(server_id):
+ return jsonify({
+ 'success': False,
+ 'error': 'Agent not connected'
+ })
+
+ # Send system:metrics command to get fresh data
+ result = agent_registry.send_command(
+ server_id=server_id,
+ action='system:metrics',
+ timeout=10.0
+ )
+
+ return jsonify(result)
+
+
+# ==================== Metrics ====================
+
+@servers_bp.route('/<server_id>/metrics', methods=['GET'])
+@jwt_required()
+def get_server_metrics(server_id):
+ """Get historical metrics for a server"""
+ server = Server.query.get(server_id)
+ if not server:
+ return jsonify({'error': 'Server not found'}), 404
+
+ # Query parameters
+ from_time = request.args.get('from')
+ to_time = request.args.get('to')
+ limit = request.args.get('limit', 100, type=int)
+
+ query = ServerMetrics.query.filter_by(server_id=server_id)
+
+ if from_time:
+ try:
+ from_dt = datetime.fromisoformat(from_time.replace('Z', '+00:00'))
+ query = query.filter(ServerMetrics.timestamp >= from_dt)
+ except:
+ pass
+
+ if to_time:
+ try:
+ to_dt = datetime.fromisoformat(to_time.replace('Z', '+00:00'))
+ query = query.filter(ServerMetrics.timestamp <= to_dt)
+ except:
+ pass
+
+ metrics = query.order_by(ServerMetrics.timestamp.desc()).limit(limit).all()
+
+ return jsonify([m.to_dict() for m in reversed(metrics)])
+
+
+@servers_bp.route('/metrics/compare', methods=['GET'])
+@jwt_required()
+def compare_server_metrics():
+ """Compare metrics across multiple servers"""
+ server_ids = request.args.get('ids', '').split(',')
+ metric = request.args.get('metric', 'cpu_percent')
+ limit = request.args.get('limit', 50, type=int)
+
+ if not server_ids or server_ids == ['']:
+ return jsonify({'error': 'Server IDs required'}), 400
+
+ result = {}
+ for server_id in server_ids:
+ server = Server.query.get(server_id)
+ if not server:
+ continue
+
+ metrics = ServerMetrics.query.filter_by(server_id=server_id)\
+ .order_by(ServerMetrics.timestamp.desc())\
+ .limit(limit)\
+ .all()
+
+ result[server_id] = {
+ 'name': server.name,
+ 'data': [
+ {
+ 'timestamp': m.timestamp.isoformat(),
+ 'value': getattr(m, metric, None)
+ }
+ for m in reversed(metrics)
+ ]
+ }
+
+ return jsonify(result)
+
+
+# ==================== Server Overview ====================
+
+@servers_bp.route('/overview', methods=['GET'])
+@jwt_required()
+def get_servers_overview():
+ """Get overview of all servers health"""
+ servers = Server.query.all()
+ connected_ids = set(agent_registry.get_connected_servers())
+
+ total = len(servers)
+ online = len(connected_ids)
+ offline = total - online
+
+ total_containers = 0
+ total_running = 0
+
+ servers_data = []
+ for server in servers:
+ is_online = server.id in connected_ids
+
+ # Get latest metrics
+ latest = server.metrics.order_by(ServerMetrics.timestamp.desc()).first()
+
+ server_summary = {
+ 'id': server.id,
+ 'name': server.name,
+ 'status': 'online' if is_online else server.status,
+ 'group_id': server.group_id,
+ 'group_name': server.group.name if server.group else None,
+ 'tags': server.tags or [],
+ }
+
+ if latest:
+ server_summary['cpu_percent'] = latest.cpu_percent
+ server_summary['memory_percent'] = latest.memory_percent
+ server_summary['disk_percent'] = latest.disk_percent
+ server_summary['container_count'] = latest.container_count
+ server_summary['container_running'] = latest.container_running
+
+ if latest.container_count:
+ total_containers += latest.container_count
+ if latest.container_running:
+ total_running += latest.container_running
+
+ servers_data.append(server_summary)
+
+ return jsonify({
+ 'summary': {
+ 'total': total,
+ 'online': online,
+ 'offline': offline,
+ 'total_containers': total_containers,
+ 'running_containers': total_running,
+ },
+ 'servers': servers_data
+ })
+
+
+# ==================== Command History ====================
+
+@servers_bp.route('/<server_id>/commands', methods=['GET'])
+@jwt_required()
+def get_command_history(server_id):
+ """Get command history for a server"""
+ server = Server.query.get(server_id)
+ if not server:
+ return jsonify({'error': 'Server not found'}), 404
+
+ limit = request.args.get('limit', 50, type=int)
+
+ commands = ServerCommand.query.filter_by(server_id=server_id)\
+ .order_by(ServerCommand.created_at.desc())\
+ .limit(limit)\
+ .all()
+
+ return jsonify([c.to_dict() for c in commands])
+
+
+# ==================== Permission Profiles ====================
+
+@servers_bp.route('/permission-profiles', methods=['GET'])
+@jwt_required()
+def get_permission_profiles():
+ """Get available permission profiles"""
+ return jsonify(PERMISSION_PROFILES)
+
+
+# ==================== Remote Docker Operations ====================
+
+from app.services.remote_docker_service import RemoteDockerService
+
+
+@servers_bp.route('/available', methods=['GET'])
+@jwt_required()
+def get_available_servers():
+ """Get list of servers available for Docker operations"""
+ servers = RemoteDockerService.get_available_servers()
+ return jsonify(servers)
+
+
+@servers_bp.route('/<server_id>/docker/containers', methods=['GET'])
+@jwt_required()
+def list_remote_containers(server_id):
+ """List containers on a remote server"""
+ all_containers = request.args.get('all', 'false').lower() == 'true'
+ user_id = get_jwt_identity()
+
+ result = RemoteDockerService.list_containers(server_id, all=all_containers, user_id=user_id)
+
+ if not result.get('success'):
+ return jsonify(result), 500 if result.get('code') != 'AGENT_OFFLINE' else 503
+
+ return jsonify(result.get('data', []))
+
+
+@servers_bp.route('/<server_id>/docker/containers/<container_id>', methods=['GET'])
+@jwt_required()
+def inspect_remote_container(server_id, container_id):
+ """Inspect a container on a remote server"""
+ user_id = get_jwt_identity()
+
+ result = RemoteDockerService.inspect_container(server_id, container_id, user_id=user_id)
+
+ if not result.get('success'):
+ return jsonify(result), 500
+
+ return jsonify(result.get('data'))
+
+
+@servers_bp.route('/<server_id>/docker/containers/<container_id>/start', methods=['POST'])
+@jwt_required()
+@developer_required
+def start_remote_container(server_id, container_id):
+ """Start a container on a remote server"""
+ user_id = get_jwt_identity()
+
+ result = RemoteDockerService.start_container(server_id, container_id, user_id=user_id)
+
+ if not result.get('success'):
+ return jsonify(result), 500
+
+ return jsonify({'message': 'Container started'})
+
+
+@servers_bp.route('/<server_id>/docker/containers/<container_id>/stop', methods=['POST'])
+@jwt_required()
+@developer_required
+def stop_remote_container(server_id, container_id):
+ """Stop a container on a remote server"""
+ user_id = get_jwt_identity()
+ data = request.get_json() or {}
+ timeout = data.get('timeout')
+
+ result = RemoteDockerService.stop_container(server_id, container_id, timeout=timeout, user_id=user_id)
+
+ if not result.get('success'):
+ return jsonify(result), 500
+
+ return jsonify({'message': 'Container stopped'})
+
+
+@servers_bp.route('/<server_id>/docker/containers/<container_id>/restart', methods=['POST'])
+@jwt_required()
+@developer_required
+def restart_remote_container(server_id, container_id):
+ """Restart a container on a remote server"""
+ user_id = get_jwt_identity()
+ data = request.get_json() or {}
+ timeout = data.get('timeout')
+
+ result = RemoteDockerService.restart_container(server_id, container_id, timeout=timeout, user_id=user_id)
+
+ if not result.get('success'):
+ return jsonify(result), 500
+
+ return jsonify({'message': 'Container restarted'})
+
+
+@servers_bp.route('/<server_id>/docker/containers/<container_id>', methods=['DELETE'])
+@jwt_required()
+@developer_required
+def remove_remote_container(server_id, container_id):
+ """Remove a container on a remote server"""
+ user_id = get_jwt_identity()
+ force = request.args.get('force', 'false').lower() == 'true'
+ remove_volumes = request.args.get('v', 'false').lower() == 'true'
+
+ result = RemoteDockerService.remove_container(
+ server_id, container_id,
+ force=force, remove_volumes=remove_volumes,
+ user_id=user_id
+ )
+
+ if not result.get('success'):
+ return jsonify(result), 500
+
+ return jsonify({'message': 'Container removed'})
+
+
+@servers_bp.route('/<server_id>/docker/containers/<container_id>/stats', methods=['GET'])
+@jwt_required()
+def get_remote_container_stats(server_id, container_id):
+ """Get container stats from a remote server"""
+ user_id = get_jwt_identity()
+
+ result = RemoteDockerService.get_container_stats(server_id, container_id, user_id=user_id)
+
+ if not result.get('success'):
+ return jsonify(result), 500
+
+ return jsonify(result.get('data'))
+
+
+@servers_bp.route('/<server_id>/docker/images', methods=['GET'])
+@jwt_required()
+def list_remote_images(server_id):
+ """List images on a remote server"""
+ user_id = get_jwt_identity()
+
+ result = RemoteDockerService.list_images(server_id, user_id=user_id)
+
+ if not result.get('success'):
+ return jsonify(result), 500
+
+ return jsonify(result.get('data', []))
+
+
+@servers_bp.route('/<server_id>/docker/images/pull', methods=['POST'])
+@jwt_required()
+@developer_required
+def pull_remote_image(server_id):
+ """Pull an image on a remote server"""
+ user_id = get_jwt_identity()
+ data = request.get_json()
+
+ if not data or not data.get('image'):
+ return jsonify({'error': 'Image name required'}), 400
+
+ result = RemoteDockerService.pull_image(server_id, data['image'], user_id=user_id)
+
+ if not result.get('success'):
+ return jsonify(result), 500
+
+ return jsonify(result)
+
+
+@servers_bp.route('/<server_id>/docker/images/<image_id>', methods=['DELETE'])
+@jwt_required()
+@developer_required
+def remove_remote_image(server_id, image_id):
+ """Remove an image on a remote server"""
+ user_id = get_jwt_identity()
+ force = request.args.get('force', 'false').lower() == 'true'
+
+ result = RemoteDockerService.remove_image(server_id, image_id, force=force, user_id=user_id)
+
+ if not result.get('success'):
+ return jsonify(result), 500
+
+ return jsonify({'message': 'Image removed'})
+
+
+@servers_bp.route('/<server_id>/docker/volumes', methods=['GET'])
+@jwt_required()
+def list_remote_volumes(server_id):
+ """List volumes on a remote server"""
+ user_id = get_jwt_identity()
+
+ result = RemoteDockerService.list_volumes(server_id, user_id=user_id)
+
+ if not result.get('success'):
+ return jsonify(result), 500
+
+ return jsonify(result.get('data', []))
+
+
+@servers_bp.route('/<server_id>/docker/networks', methods=['GET'])
+@jwt_required()
+def list_remote_networks(server_id):
+ """List networks on a remote server"""
+ user_id = get_jwt_identity()
+
+ result = RemoteDockerService.list_networks(server_id, user_id=user_id)
+
+ if not result.get('success'):
+ return jsonify(result), 500
+
+ return jsonify(result.get('data', []))
+
+
+@servers_bp.route('/<server_id>/system/metrics', methods=['GET'])
+@jwt_required()
+def get_remote_system_metrics(server_id):
+ """Get system metrics from a remote server"""
+ user_id = get_jwt_identity()
+
+ result = RemoteDockerService.get_system_metrics(server_id, user_id=user_id)
+
+ if not result.get('success'):
+ return jsonify(result), 500
+
+ return jsonify(result.get('data'))
+
+
+@servers_bp.route('/<server_id>/system/info', methods=['GET'])
+@jwt_required()
+def get_remote_system_info(server_id):
+ """Get system info from a remote server"""
+ user_id = get_jwt_identity()
+
+ result = RemoteDockerService.get_system_info(server_id, user_id=user_id)
+
+ if not result.get('success'):
+ return jsonify(result), 500
+
+ return jsonify(result.get('data'))
diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.py
index 7668ae3f..0b33ec41 100644
--- a/backend/app/models/__init__.py
+++ b/backend/app/models/__init__.py
@@ -9,9 +9,11 @@ from app.models.audit_log import AuditLog
from app.models.metrics_history import MetricsHistory
from app.models.workflow import Workflow
from app.models.webhook import GitWebhook, WebhookLog, GitDeployment
+from app.models.server import Server, ServerGroup, ServerMetrics, ServerCommand, AgentSession
__all__ = [
'User', 'Application', 'Domain', 'EnvironmentVariable', 'EnvironmentVariableHistory',
'NotificationPreferences', 'Deployment', 'DeploymentDiff', 'SystemSettings', 'AuditLog',
- 'MetricsHistory', 'Workflow', 'GitWebhook', 'WebhookLog', 'GitDeployment'
+ 'MetricsHistory', 'Workflow', 'GitWebhook', 'WebhookLog', 'GitDeployment',
+ 'Server', 'ServerGroup', 'ServerMetrics', 'ServerCommand', 'AgentSession'
]
diff --git a/backend/app/models/server.py b/backend/app/models/server.py
new file mode 100644
index 00000000..024885af
--- /dev/null
+++ b/backend/app/models/server.py
@@ -0,0 +1,332 @@
+import uuid
+import secrets
+from datetime import datetime
+from werkzeug.security import generate_password_hash, check_password_hash
+from app import db
+
+
+class ServerGroup(db.Model):
+ """Group servers for organization"""
+ __tablename__ = 'server_groups'
+
+ id = db.Column(db.String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+ name = db.Column(db.String(100), nullable=False)
+ description = db.Column(db.Text)
+ color = db.Column(db.String(7), default='#6366f1') # Hex color for UI
+ icon = db.Column(db.String(50), default='server') # Icon name
+ parent_id = db.Column(db.String(36), db.ForeignKey('server_groups.id'), nullable=True)
+
+ created_at = db.Column(db.DateTime, default=datetime.utcnow)
+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+ # Relationships
+ servers = db.relationship('Server', back_populates='group', lazy='dynamic')
+ children = db.relationship('ServerGroup', backref=db.backref('parent', remote_side=[id]))
+
+ def to_dict(self, include_servers=False):
+ result = {
+ 'id': self.id,
+ 'name': self.name,
+ 'description': self.description,
+ 'color': self.color,
+ 'icon': self.icon,
+ 'parent_id': self.parent_id,
+ 'server_count': self.servers.count(),
+ 'created_at': self.created_at.isoformat() if self.created_at else None,
+ 'updated_at': self.updated_at.isoformat() if self.updated_at else None,
+ }
+ if include_servers:
+ result['servers'] = [s.to_dict() for s in self.servers]
+ return result
+
+ def __repr__(self):
+ return f'<ServerGroup {self.name}>'
+
+
+class Server(db.Model):
+ """Represents a remote server managed by ServerKit"""
+ __tablename__ = 'servers'
+
+ id = db.Column(db.String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+
+ # Basic Info
+ name = db.Column(db.String(100), nullable=False)
+ description = db.Column(db.Text)
+ hostname = db.Column(db.String(255)) # Reported by agent
+ ip_address = db.Column(db.String(45)) # IPv4 or IPv6
+
+ # Organization
+ group_id = db.Column(db.String(36), db.ForeignKey('server_groups.id'), nullable=True)
+ tags = db.Column(db.JSON, default=list) # ["production", "us-east", "docker"]
+
+ # Status
+ status = db.Column(db.String(20), default='pending')
+ # pending, connecting, online, offline, error, maintenance
+ last_seen = db.Column(db.DateTime)
+ last_error = db.Column(db.Text)
+
+ # Agent Info
+ agent_version = db.Column(db.String(20))
+ agent_id = db.Column(db.String(36), unique=True, index=True) # Agent's UUID
+
+ # System Info (reported by agent)
+ os_type = db.Column(db.String(20)) # linux, windows, darwin
+ os_version = db.Column(db.String(100))
+ platform = db.Column(db.String(100))
+ architecture = db.Column(db.String(20)) # amd64, arm64
+ cpu_cores = db.Column(db.Integer)
+ cpu_model = db.Column(db.String(200))
+ total_memory = db.Column(db.BigInteger) # bytes
+ total_disk = db.Column(db.BigInteger) # bytes
+ docker_version = db.Column(db.String(50))
+
+ # Security
+ api_key_hash = db.Column(db.String(256)) # bcrypt hash
+ api_key_prefix = db.Column(db.String(12)) # For identification: "sk_abc123"
+ permissions = db.Column(db.JSON, default=list) # List of permission scopes
+ allowed_ips = db.Column(db.JSON, default=list) # IP whitelist (empty = all)
+
+ # Registration
+ registration_token_hash = db.Column(db.String(256))
+ registration_token_expires = db.Column(db.DateTime)
+ registered_at = db.Column(db.DateTime)
+ registered_by = db.Column(db.Integer, db.ForeignKey('users.id'))
+
+ # Timestamps
+ created_at = db.Column(db.DateTime, default=datetime.utcnow)
+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+ # Relationships
+ group = db.relationship('ServerGroup', back_populates='servers')
+ metrics = db.relationship('ServerMetrics', back_populates='server', lazy='dynamic', cascade='all, delete-orphan')
+ commands = db.relationship('ServerCommand', back_populates='server', lazy='dynamic', cascade='all, delete-orphan')
+ sessions = db.relationship('AgentSession', back_populates='server', lazy='dynamic', cascade='all, delete-orphan')
+
+ @staticmethod
+ def generate_registration_token():
+ """Generate a secure registration token"""
+ return f"sk_reg_{secrets.token_urlsafe(32)}"
+
+ @staticmethod
+ def generate_api_credentials():
+ """Generate API key and secret"""
+ api_key = f"sk_{secrets.token_urlsafe(16)}"
+ api_secret = secrets.token_urlsafe(32)
+ return api_key, api_secret
+
+ def set_registration_token(self, token):
+ """Hash and store registration token"""
+ self.registration_token_hash = generate_password_hash(token)
+
+ def verify_registration_token(self, token):
+ """Verify a registration token"""
+ if not self.registration_token_hash:
+ return False
+ if self.registration_token_expires and datetime.utcnow() > self.registration_token_expires:
+ return False
+ return check_password_hash(self.registration_token_hash, token)
+
+ def set_api_key(self, api_key):
+ """Hash and store API key"""
+ self.api_key_hash = generate_password_hash(api_key)
+ self.api_key_prefix = api_key[:12] if len(api_key) >= 12 else api_key
+
+ def verify_api_key(self, api_key):
+ """Verify an API key"""
+ if not self.api_key_hash:
+ return False
+ return check_password_hash(self.api_key_hash, api_key)
+
+ def has_permission(self, scope):
+ """Check if server/agent has a specific permission scope"""
+ if not self.permissions:
+ return False
+ if '*' in self.permissions:
+ return True
+ # Check exact match or wildcard
+ scope_parts = scope.split(':')
+ for perm in self.permissions:
+ if perm == scope:
+ return True
+ # Check wildcard patterns like 'docker:*'
+ perm_parts = perm.split(':')
+ if len(perm_parts) <= len(scope_parts):
+ match = True
+ for i, part in enumerate(perm_parts):
+ if part == '*':
+ break
+ if i >= len(scope_parts) or part != scope_parts[i]:
+ match = False
+ break
+ if match:
+ return True
+ return False
+
+ def to_dict(self, include_metrics=False):
+ result = {
+ 'id': self.id,
+ 'name': self.name,
+ 'description': self.description,
+ 'hostname': self.hostname,
+ 'ip_address': self.ip_address,
+ 'group_id': self.group_id,
+ 'group_name': self.group.name if self.group else None,
+ 'tags': self.tags or [],
+ 'status': self.status,
+ 'last_seen': self.last_seen.isoformat() if self.last_seen else None,
+ 'last_error': self.last_error,
+ 'agent_version': self.agent_version,
+ 'agent_id': self.agent_id,
+ 'os_type': self.os_type,
+ 'os_version': self.os_version,
+ 'platform': self.platform,
+ 'architecture': self.architecture,
+ 'cpu_cores': self.cpu_cores,
+ 'cpu_model': self.cpu_model,
+ 'total_memory': self.total_memory,
+ 'total_disk': self.total_disk,
+ 'docker_version': self.docker_version,
+ 'permissions': self.permissions or [],
+ 'registered_at': self.registered_at.isoformat() if self.registered_at else None,
+ 'created_at': self.created_at.isoformat() if self.created_at else None,
+ 'updated_at': self.updated_at.isoformat() if self.updated_at else None,
+ }
+ if include_metrics:
+ # Get latest metrics
+ latest = self.metrics.order_by(ServerMetrics.timestamp.desc()).first()
+ if latest:
+ result['latest_metrics'] = latest.to_dict()
+ return result
+
+ def __repr__(self):
+ return f'<Server {self.name}>'
+
+
+class ServerMetrics(db.Model):
+ """Historical metrics from servers"""
+ __tablename__ = 'server_metrics'
+
+ id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+ server_id = db.Column(db.String(36), db.ForeignKey('servers.id'), nullable=False, index=True)
+
+ timestamp = db.Column(db.DateTime, default=datetime.utcnow, index=True)
+
+ # System Metrics
+ cpu_percent = db.Column(db.Float)
+ memory_percent = db.Column(db.Float)
+ memory_used = db.Column(db.BigInteger)
+ disk_percent = db.Column(db.Float)
+ disk_used = db.Column(db.BigInteger)
+ network_rx = db.Column(db.BigInteger) # Bytes received (total)
+ network_tx = db.Column(db.BigInteger) # Bytes transmitted (total)
+ network_rx_rate = db.Column(db.Float) # Bytes/sec
+ network_tx_rate = db.Column(db.Float) # Bytes/sec
+
+ # Docker Metrics
+ container_count = db.Column(db.Integer)
+ container_running = db.Column(db.Integer)
+
+ # Additional data as JSON
+ extra = db.Column(db.JSON)
+
+ server = db.relationship('Server', back_populates='metrics')
+
+ __table_args__ = (
+ db.Index('ix_server_metrics_server_time', 'server_id', 'timestamp'),
+ )
+
+ def to_dict(self):
+ return {
+ 'id': self.id,
+ 'server_id': self.server_id,
+ 'timestamp': self.timestamp.isoformat() if self.timestamp else None,
+ 'cpu_percent': self.cpu_percent,
+ 'memory_percent': self.memory_percent,
+ 'memory_used': self.memory_used,
+ 'disk_percent': self.disk_percent,
+ 'disk_used': self.disk_used,
+ 'network_rx': self.network_rx,
+ 'network_tx': self.network_tx,
+ 'network_rx_rate': self.network_rx_rate,
+ 'network_tx_rate': self.network_tx_rate,
+ 'container_count': self.container_count,
+ 'container_running': self.container_running,
+ 'extra': self.extra,
+ }
+
+
+class ServerCommand(db.Model):
+ """Audit log of commands executed on servers"""
+ __tablename__ = 'server_commands'
+
+ id = db.Column(db.String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+ server_id = db.Column(db.String(36), db.ForeignKey('servers.id'), nullable=False, index=True)
+ user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
+
+ # Command details
+ command_type = db.Column(db.String(50)) # docker:container:start, system:exec, etc.
+ command_data = db.Column(db.JSON) # The actual command/parameters
+
+ # Execution
+ status = db.Column(db.String(20), default='pending') # pending, running, completed, failed, timeout
+ started_at = db.Column(db.DateTime)
+ completed_at = db.Column(db.DateTime)
+
+ # Result
+ result = db.Column(db.JSON)
+ error = db.Column(db.Text)
+ exit_code = db.Column(db.Integer)
+
+ created_at = db.Column(db.DateTime, default=datetime.utcnow)
+
+ server = db.relationship('Server', back_populates='commands')
+
+ def to_dict(self):
+ return {
+ 'id': self.id,
+ 'server_id': self.server_id,
+ 'user_id': self.user_id,
+ 'command_type': self.command_type,
+ 'command_data': self.command_data,
+ 'status': self.status,
+ 'started_at': self.started_at.isoformat() if self.started_at else None,
+ 'completed_at': self.completed_at.isoformat() if self.completed_at else None,
+ 'result': self.result,
+ 'error': self.error,
+ 'exit_code': self.exit_code,
+ 'created_at': self.created_at.isoformat() if self.created_at else None,
+ }
+
+
+class AgentSession(db.Model):
+ """Active agent WebSocket sessions"""
+ __tablename__ = 'agent_sessions'
+
+ id = db.Column(db.String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+ server_id = db.Column(db.String(36), db.ForeignKey('servers.id'), nullable=False, index=True)
+
+ session_token = db.Column(db.String(256)) # Current session token
+ socket_id = db.Column(db.String(100)) # SocketIO session ID
+ connected_at = db.Column(db.DateTime, default=datetime.utcnow)
+ last_heartbeat = db.Column(db.DateTime, default=datetime.utcnow)
+
+ ip_address = db.Column(db.String(45))
+ user_agent = db.Column(db.String(255)) # Agent version info
+
+ is_active = db.Column(db.Boolean, default=True, index=True)
+ disconnected_at = db.Column(db.DateTime)
+ disconnect_reason = db.Column(db.String(100))
+
+ server = db.relationship('Server', back_populates='sessions')
+
+ def to_dict(self):
+ return {
+ 'id': self.id,
+ 'server_id': self.server_id,
+ 'connected_at': self.connected_at.isoformat() if self.connected_at else None,
+ 'last_heartbeat': self.last_heartbeat.isoformat() if self.last_heartbeat else None,
+ 'ip_address': self.ip_address,
+ 'is_active': self.is_active,
+ 'disconnected_at': self.disconnected_at.isoformat() if self.disconnected_at else None,
+ 'disconnect_reason': self.disconnect_reason,
+ }
diff --git a/backend/app/services/agent_registry.py b/backend/app/services/agent_registry.py
new file mode 100644
index 00000000..f56c47b6
--- /dev/null
+++ b/backend/app/services/agent_registry.py
@@ -0,0 +1,526 @@
+"""
+AgentRegistry Service
+
+Manages connected agent sessions, routes commands to agents,
+and handles agent lifecycle events.
+"""
+
+import hmac
+import hashlib
+import secrets
+import time
+import threading
+from datetime import datetime, timedelta
+from typing import Dict, Optional, Callable, Any
+from dataclasses import dataclass, field
+from queue import Queue, Empty
+
+from app import db
+from app.models.server import Server, ServerMetrics, ServerCommand, AgentSession
+
+
+@dataclass
+class ConnectedAgent:
+ """Represents a connected agent"""
+ server_id: str
+ socket_id: str
+ session_token: str
+ connected_at: datetime
+ last_heartbeat: datetime
+ ip_address: str
+ agent_version: str
+ # Pending commands waiting for response
+ pending_commands: Dict[str, 'PendingCommand'] = field(default_factory=dict)
+
+
+@dataclass
+class PendingCommand:
+ """Represents a command waiting for response"""
+ command_id: str
+ action: str
+ params: dict
+ callback: Optional[Callable] = None
+ timeout: float = 30.0
+ created_at: float = field(default_factory=time.time)
+ result_queue: Queue = field(default_factory=Queue)
+
+
+class AgentRegistry:
+ """
+ Singleton service that manages all connected agents.
+
+ Responsibilities:
+ - Track connected agents by server_id and socket_id
+ - Route commands to the correct agent
+ - Handle command responses
+ - Manage heartbeats and detect disconnections
+ - Store metrics received from agents
+ """
+
+ _instance = None
+ _lock = threading.Lock()
+
+ def __new__(cls):
+ if cls._instance is None:
+ with cls._lock:
+ if cls._instance is None:
+ cls._instance = super().__new__(cls)
+ cls._instance._initialized = False
+ return cls._instance
+
+ def __init__(self):
+ if self._initialized:
+ return
+ self._initialized = True
+
+ # Connected agents by server_id
+ self._agents: Dict[str, ConnectedAgent] = {}
+ # Socket ID to server ID mapping
+ self._socket_to_server: Dict[str, str] = {}
+ # Lock for thread safety
+ self._lock = threading.Lock()
+ # SocketIO instance (set by init_socketio)
+ self._socketio = None
+ # Heartbeat check thread
+ self._heartbeat_thread = None
+ self._stop_heartbeat = threading.Event()
+
+ def init_socketio(self, socketio):
+ """Initialize with SocketIO instance"""
+ self._socketio = socketio
+ # Start heartbeat checker
+ self._start_heartbeat_checker()
+
+ def _start_heartbeat_checker(self):
+ """Start background thread to check for dead connections"""
+ if self._heartbeat_thread and self._heartbeat_thread.is_alive():
+ return
+
+ self._stop_heartbeat.clear()
+ self._heartbeat_thread = threading.Thread(
+ target=self._check_heartbeats,
+ daemon=True
+ )
+ self._heartbeat_thread.start()
+
+ def _check_heartbeats(self):
+ """Check for agents that haven't sent heartbeats"""
+ while not self._stop_heartbeat.is_set():
+ try:
+ now = datetime.utcnow()
+ timeout = timedelta(seconds=90) # 3 missed heartbeats
+
+ with self._lock:
+ dead_agents = []
+ for server_id, agent in self._agents.items():
+ if now - agent.last_heartbeat > timeout:
+ dead_agents.append(server_id)
+
+ for server_id in dead_agents:
+ self._handle_agent_timeout(server_id)
+
+ except Exception as e:
+ print(f"Error in heartbeat checker: {e}")
+
+ self._stop_heartbeat.wait(30) # Check every 30 seconds
+
+ def _handle_agent_timeout(self, server_id: str):
+ """Handle agent that hasn't sent heartbeats"""
+ with self._lock:
+ agent = self._agents.pop(server_id, None)
+ if agent:
+ self._socket_to_server.pop(agent.socket_id, None)
+
+ if agent:
+ # Update server status in database
+ try:
+ server = Server.query.get(server_id)
+ if server:
+ server.status = 'offline'
+ server.last_error = 'Agent heartbeat timeout'
+ db.session.commit()
+
+ # Mark session as inactive
+ session = AgentSession.query.filter_by(
+ server_id=server_id,
+ socket_id=agent.socket_id,
+ is_active=True
+ ).first()
+ if session:
+ session.is_active = False
+ session.disconnected_at = datetime.utcnow()
+ session.disconnect_reason = 'heartbeat_timeout'
+ db.session.commit()
+ except Exception as e:
+ print(f"Error updating server status: {e}")
+
+ # ==================== Connection Management ====================
+
+ def register_agent(
+ self,
+ server_id: str,
+ socket_id: str,
+ ip_address: str,
+ agent_version: str = None
+ ) -> str:
+ """
+ Register a newly connected agent.
+
+ Returns: session_token
+ """
+ session_token = secrets.token_urlsafe(32)
+
+ agent = ConnectedAgent(
+ server_id=server_id,
+ socket_id=socket_id,
+ session_token=session_token,
+ connected_at=datetime.utcnow(),
+ last_heartbeat=datetime.utcnow(),
+ ip_address=ip_address,
+ agent_version=agent_version or 'unknown'
+ )
+
+ with self._lock:
+ # Remove old connection if exists
+ old_agent = self._agents.get(server_id)
+ if old_agent:
+ self._socket_to_server.pop(old_agent.socket_id, None)
+
+ self._agents[server_id] = agent
+ self._socket_to_server[socket_id] = server_id
+
+ # Update database
+ try:
+ server = Server.query.get(server_id)
+ if server:
+ server.status = 'online'
+ server.last_seen = datetime.utcnow()
+ server.last_error = None
+ if agent_version:
+ server.agent_version = agent_version
+ db.session.commit()
+
+ # Create session record
+ session = AgentSession(
+ server_id=server_id,
+ session_token=session_token,
+ socket_id=socket_id,
+ ip_address=ip_address,
+ user_agent=f"ServerKit-Agent/{agent_version or 'unknown'}",
+ is_active=True
+ )
+ db.session.add(session)
+ db.session.commit()
+ except Exception as e:
+ print(f"Error registering agent: {e}")
+ db.session.rollback()
+
+ return session_token
+
+ def unregister_agent(self, socket_id: str, reason: str = 'disconnect'):
+ """Unregister a disconnected agent"""
+ with self._lock:
+ server_id = self._socket_to_server.pop(socket_id, None)
+ if server_id:
+ agent = self._agents.pop(server_id, None)
+
+ if server_id:
+ # Update database
+ try:
+ server = Server.query.get(server_id)
+ if server:
+ server.status = 'offline'
+ db.session.commit()
+
+ # Mark session as inactive
+ session = AgentSession.query.filter_by(
+ server_id=server_id,
+ socket_id=socket_id,
+ is_active=True
+ ).first()
+ if session:
+ session.is_active = False
+ session.disconnected_at = datetime.utcnow()
+ session.disconnect_reason = reason
+ db.session.commit()
+ except Exception as e:
+ print(f"Error unregistering agent: {e}")
+ db.session.rollback()
+
+ def get_agent(self, server_id: str) -> Optional[ConnectedAgent]:
+ """Get a connected agent by server ID"""
+ with self._lock:
+ return self._agents.get(server_id)
+
+ def get_agent_by_socket(self, socket_id: str) -> Optional[ConnectedAgent]:
+ """Get a connected agent by socket ID"""
+ with self._lock:
+ server_id = self._socket_to_server.get(socket_id)
+ if server_id:
+ return self._agents.get(server_id)
+ return None
+
+ def is_agent_connected(self, server_id: str) -> bool:
+ """Check if an agent is connected"""
+ with self._lock:
+ return server_id in self._agents
+
+ def get_connected_servers(self) -> list:
+ """Get list of connected server IDs"""
+ with self._lock:
+ return list(self._agents.keys())
+
+ # ==================== Heartbeat ====================
+
+ def update_heartbeat(self, server_id: str, metrics: dict = None):
+ """Update agent heartbeat and optionally store metrics"""
+ with self._lock:
+ agent = self._agents.get(server_id)
+ if agent:
+ agent.last_heartbeat = datetime.utcnow()
+
+ # Update server last_seen
+ try:
+ server = Server.query.get(server_id)
+ if server:
+ server.last_seen = datetime.utcnow()
+ if server.status != 'online':
+ server.status = 'online'
+ db.session.commit()
+
+ # Store metrics if provided
+ if metrics:
+ self._store_metrics(server_id, metrics)
+ except Exception as e:
+ print(f"Error updating heartbeat: {e}")
+ db.session.rollback()
+
+ def _store_metrics(self, server_id: str, metrics: dict):
+ """Store metrics from heartbeat"""
+ try:
+ metric = ServerMetrics(
+ server_id=server_id,
+ cpu_percent=metrics.get('cpu_percent'),
+ memory_percent=metrics.get('memory_percent'),
+ disk_percent=metrics.get('disk_percent'),
+ container_count=metrics.get('container_count'),
+ container_running=metrics.get('container_running'),
+ )
+ db.session.add(metric)
+ db.session.commit()
+ except Exception as e:
+ print(f"Error storing metrics: {e}")
+ db.session.rollback()
+
+ # ==================== Command Routing ====================
+
+ def send_command(
+ self,
+ server_id: str,
+ action: str,
+ params: dict = None,
+ timeout: float = 30.0,
+ user_id: int = None
+ ) -> dict:
+ """
+ Send a command to an agent and wait for response.
+
+ Args:
+ server_id: Target server ID
+ action: Command action (e.g., 'docker:container:list')
+ params: Command parameters
+ timeout: Timeout in seconds
+ user_id: User ID for audit logging
+
+ Returns:
+ dict: Command result with 'success', 'data', 'error'
+ """
+ agent = self.get_agent(server_id)
+ if not agent:
+ return {
+ 'success': False,
+ 'error': 'Agent not connected',
+ 'code': 'AGENT_OFFLINE'
+ }
+
+ # Check permissions
+ server = Server.query.get(server_id)
+ if server and not server.has_permission(action):
+ return {
+ 'success': False,
+ 'error': f'Permission denied for action: {action}',
+ 'code': 'PERMISSION_DENIED'
+ }
+
+ # Create command record
+ command_id = secrets.token_urlsafe(16)
+ command_record = ServerCommand(
+ id=command_id,
+ server_id=server_id,
+ user_id=user_id,
+ command_type=action,
+ command_data=params,
+ status='pending'
+ )
+
+ try:
+ db.session.add(command_record)
+ db.session.commit()
+ except Exception as e:
+ db.session.rollback()
+ return {
+ 'success': False,
+ 'error': f'Failed to create command record: {e}',
+ 'code': 'DB_ERROR'
+ }
+
+ # Create pending command
+ pending = PendingCommand(
+ command_id=command_id,
+ action=action,
+ params=params or {},
+ timeout=timeout
+ )
+
+ with self._lock:
+ agent.pending_commands[command_id] = pending
+
+ # Send command via WebSocket
+ try:
+ self._socketio.emit(
+ 'command',
+ {
+ 'type': 'command',
+ 'id': command_id,
+ 'action': action,
+ 'params': params or {},
+ 'timeout': int(timeout * 1000)
+ },
+ room=agent.socket_id,
+ namespace='/agent'
+ )
+
+ # Update command status
+ command_record.status = 'running'
+ command_record.started_at = datetime.utcnow()
+ db.session.commit()
+
+ except Exception as e:
+ with self._lock:
+ agent.pending_commands.pop(command_id, None)
+ command_record.status = 'failed'
+ command_record.error = str(e)
+ db.session.commit()
+ return {
+ 'success': False,
+ 'error': f'Failed to send command: {e}',
+ 'code': 'SEND_ERROR'
+ }
+
+ # Wait for response
+ try:
+ result = pending.result_queue.get(timeout=timeout)
+ except Empty:
+ result = {
+ 'success': False,
+ 'error': 'Command timeout',
+ 'code': 'TIMEOUT'
+ }
+
+ # Clean up
+ with self._lock:
+ agent.pending_commands.pop(command_id, None)
+
+ # Update command record
+ try:
+ command_record.status = 'completed' if result.get('success') else 'failed'
+ command_record.completed_at = datetime.utcnow()
+ command_record.result = result.get('data')
+ command_record.error = result.get('error')
+ db.session.commit()
+ except Exception as e:
+ db.session.rollback()
+
+ return result
+
+ def handle_command_result(self, socket_id: str, result: dict):
+ """Handle command result from agent"""
+ agent = self.get_agent_by_socket(socket_id)
+ if not agent:
+ return
+
+ command_id = result.get('command_id')
+ if not command_id:
+ return
+
+ with self._lock:
+ pending = agent.pending_commands.get(command_id)
+
+ if pending:
+ pending.result_queue.put({
+ 'success': result.get('success', False),
+ 'data': result.get('data'),
+ 'error': result.get('error'),
+ 'duration': result.get('duration')
+ })
+
+ # ==================== Authentication ====================
+
+ def verify_agent_auth(self, agent_id: str, api_key_prefix: str, signature: str, timestamp: int) -> Optional[Server]:
+ """
+ Verify agent authentication.
+
+ Args:
+ agent_id: Agent's unique ID
+ api_key_prefix: First 12 chars of API key
+ signature: HMAC-SHA256 signature
+ timestamp: Unix timestamp in milliseconds
+
+ Returns:
+ Server if authenticated, None otherwise
+ """
+ # Check timestamp (allow 5 minute window)
+ now = int(time.time() * 1000)
+ if abs(now - timestamp) > 300000: # 5 minutes
+ return None
+
+ # Find server by agent_id
+ server = Server.query.filter_by(agent_id=agent_id).first()
+ if not server:
+ return None
+
+ # Verify API key prefix matches
+ if server.api_key_prefix != api_key_prefix:
+ return None
+
+ # Note: Full signature verification would require storing the secret
+ # For now, we verify the API key prefix matches
+
+ return server
+
+ # ==================== System Info ====================
+
+ def update_system_info(self, server_id: str, info: dict):
+ """Update server system information from agent"""
+ try:
+ server = Server.query.get(server_id)
+ if server:
+ server.hostname = info.get('hostname', server.hostname)
+ server.os_type = info.get('os', server.os_type)
+ server.os_version = info.get('os_version', server.os_version)
+ server.platform = info.get('platform', server.platform)
+ server.architecture = info.get('architecture', server.architecture)
+ server.cpu_cores = info.get('cpu_cores', server.cpu_cores)
+ server.cpu_model = info.get('cpu_model', server.cpu_model)
+ server.total_memory = info.get('total_memory', server.total_memory)
+ server.total_disk = info.get('total_disk', server.total_disk)
+ server.docker_version = info.get('docker_version', server.docker_version)
+ server.agent_version = info.get('agent_version', server.agent_version)
+ db.session.commit()
+ except Exception as e:
+ print(f"Error updating system info: {e}")
+ db.session.rollback()
+
+
+# Global instance
+agent_registry = AgentRegistry()
diff --git a/backend/app/services/remote_docker_service.py b/backend/app/services/remote_docker_service.py
new file mode 100644
index 00000000..5c42ab0c
--- /dev/null
+++ b/backend/app/services/remote_docker_service.py
@@ -0,0 +1,370 @@
+"""
+Remote Docker Service
+
+Provides Docker operations on remote servers via agents.
+This service routes Docker commands to the appropriate agent
+and returns the results.
+"""
+
+from typing import Optional, List, Dict, Any
+from flask_jwt_extended import get_jwt_identity
+
+from app.services.agent_registry import agent_registry
+from app.models.server import Server
+
+
+class RemoteDockerService:
+ """
+ Service for executing Docker commands on remote servers.
+
+ All methods accept a server_id parameter to target a specific server.
+ If server_id is None or 'local', the command is executed locally
+ using the existing DockerService.
+ """
+
+ # ==================== Containers ====================
+
+ @staticmethod
+ def list_containers(server_id: str, all: bool = False, user_id: int = None) -> Dict[str, Any]:
+ """
+ List containers on a remote server.
+
+ Args:
+ server_id: Target server ID
+ all: Include stopped containers
+ user_id: User ID for audit logging
+
+ Returns:
+ dict: {success, data: [containers], error}
+ """
+ if not server_id or server_id == 'local':
+ # Use local Docker
+ from app.services.docker_service import DockerService
+ try:
+ containers = DockerService.list_containers(all=all)
+ return {'success': True, 'data': containers}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
+ return agent_registry.send_command(
+ server_id=server_id,
+ action='docker:container:list',
+ params={'all': all},
+ user_id=user_id
+ )
+
+ @staticmethod
+ def inspect_container(server_id: str, container_id: str, user_id: int = None) -> Dict[str, Any]:
+ """Inspect a container on a remote server"""
+ if not server_id or server_id == 'local':
+ from app.services.docker_service import DockerService
+ try:
+ info = DockerService.inspect_container(container_id)
+ return {'success': True, 'data': info}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
+ return agent_registry.send_command(
+ server_id=server_id,
+ action='docker:container:inspect',
+ params={'id': container_id},
+ user_id=user_id
+ )
+
+ @staticmethod
+ def start_container(server_id: str, container_id: str, user_id: int = None) -> Dict[str, Any]:
+ """Start a container on a remote server"""
+ if not server_id or server_id == 'local':
+ from app.services.docker_service import DockerService
+ try:
+ DockerService.start_container(container_id)
+ return {'success': True}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
+ return agent_registry.send_command(
+ server_id=server_id,
+ action='docker:container:start',
+ params={'id': container_id},
+ user_id=user_id
+ )
+
+ @staticmethod
+ def stop_container(server_id: str, container_id: str, timeout: int = None, user_id: int = None) -> Dict[str, Any]:
+ """Stop a container on a remote server"""
+ if not server_id or server_id == 'local':
+ from app.services.docker_service import DockerService
+ try:
+ DockerService.stop_container(container_id, timeout=timeout)
+ return {'success': True}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
+ params = {'id': container_id}
+ if timeout:
+ params['timeout'] = timeout
+
+ return agent_registry.send_command(
+ server_id=server_id,
+ action='docker:container:stop',
+ params=params,
+ user_id=user_id
+ )
+
+ @staticmethod
+ def restart_container(server_id: str, container_id: str, timeout: int = None, user_id: int = None) -> Dict[str, Any]:
+ """Restart a container on a remote server"""
+ if not server_id or server_id == 'local':
+ from app.services.docker_service import DockerService
+ try:
+ DockerService.restart_container(container_id, timeout=timeout)
+ return {'success': True}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
+ params = {'id': container_id}
+ if timeout:
+ params['timeout'] = timeout
+
+ return agent_registry.send_command(
+ server_id=server_id,
+ action='docker:container:restart',
+ params=params,
+ user_id=user_id
+ )
+
+ @staticmethod
+ def remove_container(
+ server_id: str,
+ container_id: str,
+ force: bool = False,
+ remove_volumes: bool = False,
+ user_id: int = None
+ ) -> Dict[str, Any]:
+ """Remove a container on a remote server"""
+ if not server_id or server_id == 'local':
+ from app.services.docker_service import DockerService
+ try:
+ DockerService.remove_container(container_id, force=force, v=remove_volumes)
+ return {'success': True}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
+ return agent_registry.send_command(
+ server_id=server_id,
+ action='docker:container:remove',
+ params={
+ 'id': container_id,
+ 'force': force,
+ 'remove_volumes': remove_volumes
+ },
+ user_id=user_id
+ )
+
+ @staticmethod
+ def get_container_stats(server_id: str, container_id: str, user_id: int = None) -> Dict[str, Any]:
+ """Get container stats from a remote server"""
+ if not server_id or server_id == 'local':
+ from app.services.docker_service import DockerService
+ try:
+ stats = DockerService.get_container_stats(container_id)
+ return {'success': True, 'data': stats}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
+ return agent_registry.send_command(
+ server_id=server_id,
+ action='docker:container:stats',
+ params={'id': container_id},
+ user_id=user_id
+ )
+
+ # ==================== Images ====================
+
+ @staticmethod
+ def list_images(server_id: str, user_id: int = None) -> Dict[str, Any]:
+ """List images on a remote server"""
+ if not server_id or server_id == 'local':
+ from app.services.docker_service import DockerService
+ try:
+ images = DockerService.list_images()
+ return {'success': True, 'data': images}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
+ return agent_registry.send_command(
+ server_id=server_id,
+ action='docker:image:list',
+ params={},
+ user_id=user_id
+ )
+
+ @staticmethod
+ def pull_image(server_id: str, image: str, user_id: int = None) -> Dict[str, Any]:
+ """Pull an image on a remote server"""
+ if not server_id or server_id == 'local':
+ from app.services.docker_service import DockerService
+ try:
+ result = DockerService.pull_image(image)
+ return {'success': True, 'data': result}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
+ return agent_registry.send_command(
+ server_id=server_id,
+ action='docker:image:pull',
+ params={'image': image},
+ timeout=300.0, # 5 minutes for pull
+ user_id=user_id
+ )
+
+ @staticmethod
+ def remove_image(server_id: str, image_id: str, force: bool = False, user_id: int = None) -> Dict[str, Any]:
+ """Remove an image on a remote server"""
+ if not server_id or server_id == 'local':
+ from app.services.docker_service import DockerService
+ try:
+ DockerService.remove_image(image_id, force=force)
+ return {'success': True}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
+ return agent_registry.send_command(
+ server_id=server_id,
+ action='docker:image:remove',
+ params={'id': image_id, 'force': force},
+ user_id=user_id
+ )
+
+ # ==================== Volumes ====================
+
+ @staticmethod
+ def list_volumes(server_id: str, user_id: int = None) -> Dict[str, Any]:
+ """List volumes on a remote server"""
+ if not server_id or server_id == 'local':
+ from app.services.docker_service import DockerService
+ try:
+ volumes = DockerService.list_volumes()
+ return {'success': True, 'data': volumes}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
+ return agent_registry.send_command(
+ server_id=server_id,
+ action='docker:volume:list',
+ params={},
+ user_id=user_id
+ )
+
+ @staticmethod
+ def remove_volume(server_id: str, name: str, force: bool = False, user_id: int = None) -> Dict[str, Any]:
+ """Remove a volume on a remote server"""
+ if not server_id or server_id == 'local':
+ from app.services.docker_service import DockerService
+ try:
+ DockerService.remove_volume(name, force=force)
+ return {'success': True}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
+ return agent_registry.send_command(
+ server_id=server_id,
+ action='docker:volume:remove',
+ params={'name': name, 'force': force},
+ user_id=user_id
+ )
+
+ # ==================== Networks ====================
+
+ @staticmethod
+ def list_networks(server_id: str, user_id: int = None) -> Dict[str, Any]:
+ """List networks on a remote server"""
+ if not server_id or server_id == 'local':
+ from app.services.docker_service import DockerService
+ try:
+ networks = DockerService.list_networks()
+ return {'success': True, 'data': networks}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
+ return agent_registry.send_command(
+ server_id=server_id,
+ action='docker:network:list',
+ params={},
+ user_id=user_id
+ )
+
+ # ==================== System ====================
+
+ @staticmethod
+ def get_system_metrics(server_id: str, user_id: int = None) -> Dict[str, Any]:
+ """Get system metrics from a remote server"""
+ if not server_id or server_id == 'local':
+ from app.services.system_service import SystemService
+ try:
+ metrics = SystemService.get_all_metrics()
+ return {'success': True, 'data': metrics}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
+ return agent_registry.send_command(
+ server_id=server_id,
+ action='system:metrics',
+ params={},
+ user_id=user_id
+ )
+
+ @staticmethod
+ def get_system_info(server_id: str, user_id: int = None) -> Dict[str, Any]:
+ """Get system info from a remote server"""
+ if not server_id or server_id == 'local':
+ from app.services.system_service import SystemService
+ try:
+ info = SystemService.get_system_info()
+ return {'success': True, 'data': info}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
+ return agent_registry.send_command(
+ server_id=server_id,
+ action='system:info',
+ params={},
+ user_id=user_id
+ )
+
+ # ==================== Utility ====================
+
+ @staticmethod
+ def get_available_servers() -> List[Dict[str, Any]]:
+ """
+ Get list of available servers for Docker operations.
+
+ Returns servers that are online and have Docker permissions.
+ """
+ # Always include local server
+ servers = [{
+ 'id': 'local',
+ 'name': 'Local (this server)',
+ 'status': 'online',
+ 'is_local': True
+ }]
+
+ # Get remote servers
+ connected_ids = set(agent_registry.get_connected_servers())
+
+ remote_servers = Server.query.filter(
+ Server.status.in_(['online', 'connecting'])
+ ).all()
+
+ for server in remote_servers:
+ has_docker_perm = server.has_permission('docker:container:read')
+ servers.append({
+ 'id': server.id,
+ 'name': server.name,
+ 'status': 'online' if server.id in connected_ids else server.status,
+ 'is_local': False,
+ 'has_docker': has_docker_perm,
+ 'group_name': server.group.name if server.group else None
+ })
+
+ return servers
diff --git a/frontend/dist/index.html b/frontend/dist/index.html
index 84bb6def..6d44a1eb 100644
--- a/frontend/dist/index.html
+++ b/frontend/dist/index.html
@@ -6,8 +6,8 @@
<link rel="icon" type="image/svg+xml" href="/vite.svg" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>React Dashboard Template</title>
- <script type="module" crossorigin src="/assets/index-D6suKtfZ.js"></script>
- <link rel="stylesheet" crossorigin href="/assets/index-C57Nuizn.css">
+ <script type="module" crossorigin src="/assets/index-Damd6cMY.js"></script>
+ <link rel="stylesheet" crossorigin href="/assets/index-BnOaCt6L.css">
</head>
<body>
diff --git a/frontend/src/App.jsx b/frontend/src/App.jsx
index 714100ee..52f91007 100644
--- a/frontend/src/App.jsx
+++ b/frontend/src/App.jsx
@@ -25,6 +25,8 @@ import CronJobs from './pages/CronJobs';
import Security from './pages/Security';
import Templates from './pages/Templates';
import WorkflowBuilder from './pages/WorkflowBuilder';
+import Servers from './pages/Servers';
+import ServerDetail from './pages/ServerDetail';
function PrivateRoute({ children }) {
const { isAuthenticated, loading, needsSetup } = useAuth();
@@ -107,6 +109,9 @@ function AppRoutes() {
<Route path="databases" element={<Databases />} />
<Route path="ssl" element={<div className="page">SSL Certificates</div>} />
<Route path="docker" element={<Docker />} />
+ <Route path="servers" element={<Servers />} />
+ <Route path="servers/:id" element={<ServerDetail />} />
+ <Route path="servers/:id/docker" element={<ServerDetail />} />
<Route path="firewall" element={<Navigate to="/security" replace />} />
<Route path="git" element={<Git />} />
<Route path="files" element={<FileManager />} />
diff --git a/frontend/src/components/Sidebar.jsx b/frontend/src/components/Sidebar.jsx
index 4112184c..c83e92f3 100644
--- a/frontend/src/components/Sidebar.jsx
+++ b/frontend/src/components/Sidebar.jsx
@@ -33,6 +33,15 @@ const Sidebar = () => {
<div className="menu-label">Infrastructure</div>
<nav className="nav">
+ <NavLink to="/servers" className={({ isActive }) => `nav-item ${isActive ? 'active' : ''}`}>
+ <svg viewBox="0 0 24 24">
+ <rect x="2" y="2" width="20" height="8" rx="2" ry="2"/>
+ <rect x="2" y="14" width="20" height="8" rx="2" ry="2"/>
+ <line x1="6" y1="6" x2="6.01" y2="6"/>
+ <line x1="6" y1="18" x2="6.01" y2="18"/>
+ </svg>
+ Servers
+ </NavLink>
<NavLink to="/domains" className={({ isActive }) => `nav-item ${isActive ? 'active' : ''}`}>
<svg viewBox="0 0 24 24">
<circle cx="12" cy="12" r="10"/>
diff --git a/frontend/src/pages/Docker.jsx b/frontend/src/pages/Docker.jsx
index 1a552007..11bc33d8 100644
--- a/frontend/src/pages/Docker.jsx
+++ b/frontend/src/pages/Docker.jsx
@@ -1,11 +1,17 @@
-import React, { useState, useEffect, useCallback } from 'react';
+import React, { useState, useEffect, useCallback, createContext, useContext } from 'react';
import api from '../services/api';
import { useToast } from '../contexts/ToastContext';
+// Server context for Docker operations
+const ServerContext = createContext({ serverId: 'local', serverName: 'Local' });
+const useServer = () => useContext(ServerContext);
+
const Docker = () => {
const [activeTab, setActiveTab] = useState('containers');
const [dockerStatus, setDockerStatus] = useState(null);
const [loading, setLoading] = useState(true);
+ const [servers, setServers] = useState([]);
+ const [selectedServer, setSelectedServer] = useState({ id: 'local', name: 'Local (this server)' });
const [stats, setStats] = useState({
containers: { total: 0, running: 0, stopped: 0 },
images: { total: 0, size: '0 B' },
@@ -14,32 +20,77 @@ const Docker = () => {
});
useEffect(() => {
- checkDockerStatus();
+ loadServers();
}, []);
+ useEffect(() => {
+ checkDockerStatus();
+ }, [selectedServer]);
+
+ async function loadServers() {
+ try {
+ const data = await api.getAvailableServers();
+ setServers(data.servers || []);
+ } catch (err) {
+ console.error('Failed to load servers:', err);
+ // Default to just local
+ setServers([{ id: 'local', name: 'Local (this server)', status: 'online' }]);
+ }
+ }
+
async function checkDockerStatus() {
+ setLoading(true);
try {
- const status = await api.getDockerStatus();
- setDockerStatus(status);
- if (status.installed) {
- loadStats();
+ if (selectedServer.id === 'local') {
+ const status = await api.getDockerStatus();
+ setDockerStatus(status);
+ if (status.installed) {
+ loadStats();
+ } else {
+ setLoading(false);
+ }
+ } else {
+ // For remote servers, check if the agent is online
+ const serverData = await api.getServer(selectedServer.id);
+ if (serverData.server?.status === 'online') {
+ setDockerStatus({ installed: true, running: true });
+ loadStats();
+ } else {
+ setDockerStatus({ installed: false, error: 'Server agent is offline' });
+ setLoading(false);
+ }
}
} catch (err) {
setDockerStatus({ installed: false, error: err.message });
- } finally {
setLoading(false);
}
}
async function loadStats() {
try {
- const [containersData, imagesData, volumesData, networksData, diskUsage] = await Promise.all([
- api.getContainers(true),
- api.getImages(),
- api.getVolumes(),
- api.getNetworks(),
- api.getDockerDiskUsage().catch(() => null)
- ]);
+ let containersData, imagesData, volumesData, networksData;
+
+ if (selectedServer.id === 'local') {
+ [containersData, imagesData, volumesData, networksData] = await Promise.all([
+ api.getContainers(true),
+ api.getImages(),
+ api.getVolumes(),
+ api.getNetworks()
+ ]);
+ } else {
+ [containersData, imagesData, volumesData, networksData] = await Promise.all([
+ api.getRemoteContainers(selectedServer.id, true),
+ api.getRemoteImages(selectedServer.id),
+ api.getRemoteVolumes(selectedServer.id),
+ api.getRemoteNetworks(selectedServer.id)
+ ]);
+
+ // Transform remote response format
+ if (containersData.success) containersData = { containers: containersData.data };
+ if (imagesData.success) imagesData = { images: imagesData.data };
+ if (volumesData.success) volumesData = { volumes: volumesData.data };
+ if (networksData.success) networksData = { networks: networksData.data };
+ }
const containers = containersData.containers || [];
const images = imagesData.images || [];
@@ -56,13 +107,15 @@ const Docker = () => {
},
images: {
total: images.length,
- size: diskUsage?.usage?.Images?.Size || formatTotalImageSize(images)
+ size: formatTotalImageSize(images)
},
volumes: { total: volumes.length },
networks: { total: networks.length }
});
} catch (err) {
console.error('Failed to load stats:', err);
+ } finally {
+ setLoading(false);
}
}
@@ -140,7 +193,20 @@ const Docker = () => {
{ id: 'networks', label: 'Networks' }
];
+ function handleServerChange(e) {
+ const serverId = e.target.value;
+ const server = servers.find(s => s.id === serverId) || { id: 'local', name: 'Local' };
+ setSelectedServer(server);
+ }
+
+ const serverContextValue = {
+ serverId: selectedServer.id,
+ serverName: selectedServer.name,
+ isRemote: selectedServer.id !== 'local'
+ };
+
return (
+ <ServerContext.Provider value={serverContextValue}>
<div className="docker-page-new">
<div className="docker-page-header">
<div className="docker-page-title">
@@ -148,6 +214,16 @@ const Docker = () => {
<div className="docker-page-subtitle">Manage Containers, Images, and Networks</div>
</div>
<div className="docker-page-actions">
+ <div className="server-selector">
+ <ServerSelectorIcon />
+ <select value={selectedServer.id} onChange={handleServerChange}>
+ {servers.map(server => (
+ <option key={server.id} value={server.id} disabled={server.status === 'offline'}>
+ {server.name} {server.status === 'offline' ? '(Offline)' : ''}
+ </option>
+ ))}
+ </select>
+ </div>
{activeTab === 'containers' && <RunContainerButton />}
{activeTab === 'images' && <PullImageButton />}
{activeTab === 'networks' && <CreateNetworkButton />}
@@ -207,9 +283,20 @@ const Docker = () => {
</div>
</div>
</div>
+ </ServerContext.Provider>
);
};
+// Server Selector Icon
+const ServerSelectorIcon = () => (
+ <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+ <rect x="2" y="2" width="20" height="8" rx="2" ry="2"/>
+ <rect x="2" y="14" width="20" height="8" rx="2" ry="2"/>
+ <line x1="6" y1="6" x2="6.01" y2="6"/>
+ <line x1="6" y1="18" x2="6.01" y2="18"/>
+ </svg>
+);
+
// Action Buttons
const RunContainerButton = () => {
const [showModal, setShowModal] = useState(false);
@@ -362,6 +449,7 @@ const TrashIcon = () => (
// Containers Tab
const ContainersTab = ({ onStatsChange }) => {
const toast = useToast();
+ const { serverId, isRemote } = useServer();
const [containers, setContainers] = useState([]);
const [containerStats, setContainerStats] = useState({});
const [loading, setLoading] = useState(true);
@@ -372,12 +460,18 @@ const ContainersTab = ({ onStatsChange }) => {
useEffect(() => {
loadContainers();
- }, [showAll]);
+ }, [showAll, serverId]);
async function loadContainers() {
setLoading(true);
try {
- const data = await api.getContainers(showAll);
+ let data;
+ if (isRemote) {
+ const result = await api.getRemoteContainers(serverId, showAll);
+ data = result.success ? { containers: result.data || [] } : { containers: [] };
+ } else {
+ data = await api.getContainers(showAll);
+ }
const containerList = data.containers || [];
setContainers(containerList);
@@ -385,7 +479,13 @@ const ContainersTab = ({ onStatsChange }) => {
const runningContainers = containerList.filter(c => c.state === 'running');
const statsPromises = runningContainers.map(async (c) => {
try {
- const statsData = await api.getContainerStats(c.id);
+ let statsData;
+ if (isRemote) {
+ const result = await api.getRemoteContainerStats(serverId, c.id);
+ statsData = result.success ? { stats: result.data } : { stats: null };
+ } else {
+ statsData = await api.getContainerStats(c.id);
+ }
return { id: c.id, stats: statsData.stats };
} catch {
return { id: c.id, stats: null };
@@ -408,17 +508,33 @@ const ContainersTab = ({ onStatsChange }) => {
async function handleAction(containerId, action) {
try {
if (action === 'start') {
- await api.startContainer(containerId);
+ if (isRemote) {
+ await api.startRemoteContainer(serverId, containerId);
+ } else {
+ await api.startContainer(containerId);
+ }
toast.success('Container started');
} else if (action === 'stop') {
- await api.stopContainer(containerId);
+ if (isRemote) {
+ await api.stopRemoteContainer(serverId, containerId);
+ } else {
+ await api.stopContainer(containerId);
+ }
toast.success('Container stopped');
} else if (action === 'restart') {
- await api.restartContainer(containerId);
+ if (isRemote) {
+ await api.restartRemoteContainer(serverId, containerId);
+ } else {
+ await api.restartContainer(containerId);
+ }
toast.success('Container restarted');
} else if (action === 'remove') {
if (!confirm('Remove this container?')) return;
- await api.removeContainer(containerId, true);
+ if (isRemote) {
+ await api.removeRemoteContainer(serverId, containerId, true);
+ } else {
+ await api.removeContainer(containerId, true);
+ }
toast.success('Container removed');
}
loadContainers();
@@ -597,18 +713,25 @@ const ContainersTab = ({ onStatsChange }) => {
// Images Tab
const ImagesTab = ({ onStatsChange }) => {
const toast = useToast();
+ const { serverId, isRemote } = useServer();
const [images, setImages] = useState([]);
const [loading, setLoading] = useState(true);
const [searchTerm, setSearchTerm] = useState('');
useEffect(() => {
loadImages();
- }, []);
+ }, [serverId]);
async function loadImages() {
setLoading(true);
try {
- const data = await api.getImages();
+ let data;
+ if (isRemote) {
+ const result = await api.getRemoteImages(serverId);
+ data = result.success ? { images: result.data || [] } : { images: [] };
+ } else {
+ data = await api.getImages();
+ }
setImages(data.images || []);
} catch (err) {
console.error('Failed to load images:', err);
@@ -621,7 +744,11 @@ const ImagesTab = ({ onStatsChange }) => {
if (!confirm('Remove this image?')) return;
try {
- await api.removeImage(imageId, true);
+ if (isRemote) {
+ await api.removeRemoteImage(serverId, imageId, true);
+ } else {
+ await api.removeImage(imageId, true);
+ }
toast.success('Image removed successfully');
loadImages();
onStatsChange?.();
@@ -704,17 +831,24 @@ const ImagesTab = ({ onStatsChange }) => {
// Networks Tab
const NetworksTab = ({ onStatsChange }) => {
const toast = useToast();
+ const { serverId, isRemote } = useServer();
const [networks, setNetworks] = useState([]);
const [loading, setLoading] = useState(true);
useEffect(() => {
loadNetworks();
- }, []);
+ }, [serverId]);
async function loadNetworks() {
setLoading(true);
try {
- const data = await api.getNetworks();
+ let data;
+ if (isRemote) {
+ const result = await api.getRemoteNetworks(serverId);
+ data = result.success ? { networks: result.data || [] } : { networks: [] };
+ } else {
+ data = await api.getNetworks();
+ }
setNetworks(data.networks || []);
} catch (err) {
console.error('Failed to load networks:', err);
@@ -791,17 +925,24 @@ const NetworksTab = ({ onStatsChange }) => {
// Volumes Tab
const VolumesTab = ({ onStatsChange }) => {
const toast = useToast();
+ const { serverId, isRemote } = useServer();
const [volumes, setVolumes] = useState([]);
const [loading, setLoading] = useState(true);
useEffect(() => {
loadVolumes();
- }, []);
+ }, [serverId]);
async function loadVolumes() {
setLoading(true);
try {
- const data = await api.getVolumes();
+ let data;
+ if (isRemote) {
+ const result = await api.getRemoteVolumes(serverId);
+ data = result.success ? { volumes: result.data || [] } : { volumes: [] };
+ } else {
+ data = await api.getVolumes();
+ }
setVolumes(data.volumes || []);
} catch (err) {
console.error('Failed to load volumes:', err);
diff --git a/frontend/src/pages/ServerDetail.jsx b/frontend/src/pages/ServerDetail.jsx
new file mode 100644
index 00000000..d47d155a
--- /dev/null
+++ b/frontend/src/pages/ServerDetail.jsx
@@ -0,0 +1,876 @@
+import React, { useState, useEffect, useCallback } from 'react';
+import { useParams, Link, useNavigate } from 'react-router-dom';
+import api from '../services/api';
+import { useToast } from '../contexts/ToastContext';
+
+const ServerDetail = () => {
+ const { id } = useParams();
+ const navigate = useNavigate();
+ const [server, setServer] = useState(null);
+ const [metrics, setMetrics] = useState(null);
+ const [systemInfo, setSystemInfo] = useState(null);
+ const [activeTab, setActiveTab] = useState('overview');
+ const [loading, setLoading] = useState(true);
+ const [error, setError] = useState(null);
+ const toast = useToast();
+
+ const loadServer = useCallback(async () => {
+ try {
+ const data = await api.getServer(id);
+ setServer(data.server);
+ setError(null);
+ } catch (err) {
+ setError(err.message);
+ } finally {
+ setLoading(false);
+ }
+ }, [id]);
+
+ const loadMetrics = useCallback(async () => {
+ if (!server || server.status !== 'online') return;
+ try {
+ const data = await api.getRemoteSystemMetrics(id);
+ if (data.success) {
+ setMetrics(data.data);
+ }
+ } catch (err) {
+ console.error('Failed to load metrics:', err);
+ }
+ }, [id, server]);
+
+ const loadSystemInfo = useCallback(async () => {
+ if (!server || server.status !== 'online') return;
+ try {
+ const data = await api.getRemoteSystemInfo(id);
+ if (data.success) {
+ setSystemInfo(data.data);
+ }
+ } catch (err) {
+ console.error('Failed to load system info:', err);
+ }
+ }, [id, server]);
+
+ useEffect(() => {
+ loadServer();
+ }, [loadServer]);
+
+ useEffect(() => {
+ if (server?.status === 'online') {
+ loadMetrics();
+ loadSystemInfo();
+ const interval = setInterval(loadMetrics, 10000);
+ return () => clearInterval(interval);
+ }
+ }, [server, loadMetrics, loadSystemInfo]);
+
+ async function handleDeleteServer() {
+ if (!confirm('Are you sure you want to remove this server? This action cannot be undone.')) return;
+
+ try {
+ await api.deleteServer(id);
+ toast.success('Server removed successfully');
+ navigate('/servers');
+ } catch (err) {
+ toast.error(err.message || 'Failed to remove server');
+ }
+ }
+
+ async function handlePingServer() {
+ try {
+ const result = await api.pingServer(id);
+ if (result.success) {
+ toast.success(`Server responded in ${result.latency}ms`);
+ loadServer();
+ } else {
+ toast.error('Server did not respond');
+ }
+ } catch (err) {
+ toast.error('Failed to ping server');
+ }
+ }
+
+ async function handleRegenerateToken() {
+ if (!confirm('Generate a new registration token? The old token will be invalidated.')) return;
+
+ try {
+ const result = await api.generateRegistrationToken(id);
+ toast.success('New registration token generated');
+ setServer(prev => ({ ...prev, registration_token: result.token }));
+ } catch (err) {
+ toast.error(err.message || 'Failed to generate token');
+ }
+ }
+
+ if (loading) {
+ return <div className="loading">Loading server details...</div>;
+ }
+
+ if (error) {
+ return (
+ <div className="error-page">
+ <h2>Error Loading Server</h2>
+ <p>{error}</p>
+ <Link to="/servers" className="btn btn-primary">Back to Servers</Link>
+ </div>
+ );
+ }
+
+ if (!server) {
+ return (
+ <div className="error-page">
+ <h2>Server Not Found</h2>
+ <p>The requested server could not be found.</p>
+ <Link to="/servers" className="btn btn-primary">Back to Servers</Link>
+ </div>
+ );
+ }
+
+ const statusColors = {
+ online: '#10B981',
+ offline: '#EF4444',
+ connecting: '#F59E0B',
+ pending: '#6B7280'
+ };
+
+ const tabs = [
+ { id: 'overview', label: 'Overview' },
+ { id: 'docker', label: 'Docker' },
+ { id: 'metrics', label: 'Metrics' },
+ { id: 'settings', label: 'Settings' }
+ ];
+
+ return (
+ <div className="server-detail-page">
+ <div className="page-header">
+ <div className="page-breadcrumb">
+ <Link to="/servers">Servers</Link>
+ <span className="breadcrumb-separator">/</span>
+ <span>{server.name}</span>
+ </div>
+ <div className="page-header-content">
+ <div className="server-title">
+ <div
+ className="status-dot large"
+ style={{ backgroundColor: statusColors[server.status] }}
+ title={server.status}
+ />
+ <h1>{server.name}</h1>
+ </div>
+ <p className="page-description">
+ {server.hostname || server.ip_address}
+ {server.description && ` - ${server.description}`}
+ </p>
+ </div>
+ <div className="page-header-actions">
+ <button className="btn btn-secondary" onClick={handlePingServer}>
+ <RefreshIcon /> Ping
+ </button>
+ <button className="btn btn-danger" onClick={handleDeleteServer}>
+ <TrashIcon /> Remove
+ </button>
+ </div>
+ </div>
+
+ <div className="server-detail-tabs">
+ {tabs.map(tab => (
+ <button
+ key={tab.id}
+ className={`tab-btn ${activeTab === tab.id ? 'active' : ''}`}
+ onClick={() => setActiveTab(tab.id)}
+ >
+ {tab.label}
+ </button>
+ ))}
+ </div>
+
+ <div className="server-detail-content">
+ {activeTab === 'overview' && (
+ <OverviewTab
+ server={server}
+ metrics={metrics}
+ systemInfo={systemInfo}
+ />
+ )}
+ {activeTab === 'docker' && (
+ <DockerTab serverId={id} serverStatus={server.status} />
+ )}
+ {activeTab === 'metrics' && (
+ <MetricsTab serverId={id} metrics={metrics} />
+ )}
+ {activeTab === 'settings' && (
+ <SettingsTab
+ server={server}
+ onUpdate={loadServer}
+ onRegenerateToken={handleRegenerateToken}
+ />
+ )}
+ </div>
+ </div>
+ );
+};
+
+const OverviewTab = ({ server, metrics, systemInfo }) => {
+ const formatBytes = (bytes) => {
+ if (!bytes) return 'N/A';
+ const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+ const i = Math.floor(Math.log(bytes) / Math.log(1024));
+ return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${sizes[i]}`;
+ };
+
+ const formatUptime = (seconds) => {
+ if (!seconds) return 'N/A';
+ const days = Math.floor(seconds / 86400);
+ const hours = Math.floor((seconds % 86400) / 3600);
+ if (days > 0) return `${days}d ${hours}h`;
+ const mins = Math.floor((seconds % 3600) / 60);
+ return `${hours}h ${mins}m`;
+ };
+
+ return (
+ <div className="overview-tab">
+ <div className="overview-grid">
+ <div className="info-card">
+ <h3>Server Information</h3>
+ <div className="info-list">
+ <div className="info-item">
+ <span className="info-label">Status</span>
+ <span className={`status-badge ${server.status}`}>{server.status}</span>
+ </div>
+ <div className="info-item">
+ <span className="info-label">Hostname</span>
+ <span className="info-value">{server.hostname || 'N/A'}</span>
+ </div>
+ <div className="info-item">
+ <span className="info-label">IP Address</span>
+ <span className="info-value">{server.ip_address || 'N/A'}</span>
+ </div>
+ <div className="info-item">
+ <span className="info-label">Group</span>
+ <span className="info-value">{server.group_name || 'Ungrouped'}</span>
+ </div>
+ <div className="info-item">
+ <span className="info-label">Last Seen</span>
+ <span className="info-value">
+ {server.last_seen ? new Date(server.last_seen).toLocaleString() : 'Never'}
+ </span>
+ </div>
+ </div>
+ </div>
+
+ <div className="info-card">
+ <h3>System Information</h3>
+ <div className="info-list">
+ <div className="info-item">
+ <span className="info-label">Operating System</span>
+ <span className="info-value">
+ {systemInfo?.os || server.os_type || 'Unknown'}
+ {systemInfo?.os_version && ` ${systemInfo.os_version}`}
+ </span>
+ </div>
+ <div className="info-item">
+ <span className="info-label">Architecture</span>
+ <span className="info-value">{systemInfo?.architecture || server.architecture || 'N/A'}</span>
+ </div>
+ <div className="info-item">
+ <span className="info-label">CPU</span>
+ <span className="info-value">
+ {systemInfo?.cpu_model || 'N/A'}
+ {systemInfo?.cpu_cores && ` (${systemInfo.cpu_cores} cores)`}
+ </span>
+ </div>
+ <div className="info-item">
+ <span className="info-label">Total Memory</span>
+ <span className="info-value">{formatBytes(systemInfo?.total_memory)}</span>
+ </div>
+ <div className="info-item">
+ <span className="info-label">Total Disk</span>
+ <span className="info-value">{formatBytes(systemInfo?.total_disk)}</span>
+ </div>
+ </div>
+ </div>
+
+ <div className="info-card">
+ <h3>Agent Information</h3>
+ <div className="info-list">
+ <div className="info-item">
+ <span className="info-label">Agent Version</span>
+ <span className="info-value">{server.agent_version || 'Not installed'}</span>
+ </div>
+ <div className="info-item">
+ <span className="info-label">Agent ID</span>
+ <span className="info-value mono">{server.agent_id || 'N/A'}</span>
+ </div>
+ <div className="info-item">
+ <span className="info-label">Docker Version</span>
+ <span className="info-value">{server.docker_version || systemInfo?.docker_version || 'N/A'}</span>
+ </div>
+ <div className="info-item">
+ <span className="info-label">Uptime</span>
+ <span className="info-value">{formatUptime(metrics?.uptime)}</span>
+ </div>
+ </div>
+ </div>
+
+ {server.status === 'online' && metrics && (
+ <div className="info-card metrics-card">
+ <h3>Current Resources</h3>
+ <div className="resource-meters">
+ <ResourceMeter label="CPU" value={metrics.cpu_percent} color="#6366F1" />
+ <ResourceMeter label="Memory" value={metrics.memory_percent} color="#10B981" />
+ <ResourceMeter label="Disk" value={metrics.disk_percent} color="#F59E0B" />
+ </div>
+ </div>
+ )}
+
+ {server.status !== 'online' && (
+ <div className="info-card offline-card">
+ <div className="offline-message">
+ <OfflineIcon />
+ <h4>Server Offline</h4>
+ <p>
+ {server.status === 'pending'
+ ? 'Waiting for agent installation...'
+ : 'Unable to connect to the server agent.'}
+ </p>
+ </div>
+ </div>
+ )}
+ </div>
+ </div>
+ );
+};
+
+const ResourceMeter = ({ label, value, color }) => {
+ const safeValue = Math.min(Math.max(value || 0, 0), 100);
+ return (
+ <div className="resource-meter">
+ <div className="resource-header">
+ <span className="resource-label">{label}</span>
+ <span className="resource-value">{safeValue.toFixed(1)}%</span>
+ </div>
+ <div className="resource-bar">
+ <div
+ className="resource-fill"
+ style={{
+ width: `${safeValue}%`,
+ backgroundColor: safeValue > 80 ? '#EF4444' : color
+ }}
+ />
+ </div>
+ </div>
+ );
+};
+
+const DockerTab = ({ serverId, serverStatus }) => {
+ const [containers, setContainers] = useState([]);
+ const [images, setImages] = useState([]);
+ const [loading, setLoading] = useState(true);
+ const [subTab, setSubTab] = useState('containers');
+ const toast = useToast();
+
+ useEffect(() => {
+ if (serverStatus === 'online') {
+ loadDockerData();
+ } else {
+ setLoading(false);
+ }
+ }, [serverId, serverStatus]);
+
+ async function loadDockerData() {
+ setLoading(true);
+ try {
+ const [containersRes, imagesRes] = await Promise.all([
+ api.getRemoteContainers(serverId, true),
+ api.getRemoteImages(serverId)
+ ]);
+
+ if (containersRes.success) setContainers(containersRes.data || []);
+ if (imagesRes.success) setImages(imagesRes.data || []);
+ } catch (err) {
+ console.error('Failed to load Docker data:', err);
+ } finally {
+ setLoading(false);
+ }
+ }
+
+ async function handleContainerAction(containerId, action) {
+ try {
+ let result;
+ if (action === 'start') {
+ result = await api.startRemoteContainer(serverId, containerId);
+ toast.success('Container started');
+ } else if (action === 'stop') {
+ result = await api.stopRemoteContainer(serverId, containerId);
+ toast.success('Container stopped');
+ } else if (action === 'restart') {
+ result = await api.restartRemoteContainer(serverId, containerId);
+ toast.success('Container restarted');
+ } else if (action === 'remove') {
+ if (!confirm('Remove this container?')) return;
+ result = await api.removeRemoteContainer(serverId, containerId, true);
+ toast.success('Container removed');
+ }
+ loadDockerData();
+ } catch (err) {
+ toast.error(err.message || `Failed to ${action} container`);
+ }
+ }
+
+ if (serverStatus !== 'online') {
+ return (
+ <div className="offline-notice">
+ <OfflineIcon />
+ <h4>Server Offline</h4>
+ <p>Docker management requires the server to be online.</p>
+ </div>
+ );
+ }
+
+ if (loading) {
+ return <div className="loading">Loading Docker data...</div>;
+ }
+
+ return (
+ <div className="docker-tab">
+ <div className="docker-sub-tabs">
+ <button
+ className={`sub-tab ${subTab === 'containers' ? 'active' : ''}`}
+ onClick={() => setSubTab('containers')}
+ >
+ Containers ({containers.length})
+ </button>
+ <button
+ className={`sub-tab ${subTab === 'images' ? 'active' : ''}`}
+ onClick={() => setSubTab('images')}
+ >
+ Images ({images.length})
+ </button>
+ </div>
+
+ {subTab === 'containers' && (
+ <div className="containers-list">
+ {containers.length === 0 ? (
+ <div className="empty-list">No containers found on this server.</div>
+ ) : (
+ <table className="data-table">
+ <thead>
+ <tr>
+ <th>Name</th>
+ <th>Image</th>
+ <th>Status</th>
+ <th>Ports</th>
+ <th>Actions</th>
+ </tr>
+ </thead>
+ <tbody>
+ {containers.map(container => {
+ const isRunning = container.state === 'running';
+ return (
+ <tr key={container.id}>
+ <td>
+ <span className="container-name">{container.name}</span>
+ <span className="container-id">{container.id?.substring(0, 12)}</span>
+ </td>
+ <td>{container.image}</td>
+ <td>
+ <span className={`status-pill ${isRunning ? 'running' : 'stopped'}`}>
+ {container.state}
+ </span>
+ </td>
+ <td>{container.ports || '-'}</td>
+ <td className="actions-cell">
+ {isRunning ? (
+ <>
+ <button
+ className="btn-icon"
+ onClick={() => handleContainerAction(container.id, 'restart')}
+ title="Restart"
+ >
+ <RefreshIcon />
+ </button>
+ <button
+ className="btn-icon danger"
+ onClick={() => handleContainerAction(container.id, 'stop')}
+ title="Stop"
+ >
+ <StopIcon />
+ </button>
+ </>
+ ) : (
+ <>
+ <button
+ className="btn-icon success"
+ onClick={() => handleContainerAction(container.id, 'start')}
+ title="Start"
+ >
+ <PlayIcon />
+ </button>
+ <button
+ className="btn-icon danger"
+ onClick={() => handleContainerAction(container.id, 'remove')}
+ title="Remove"
+ >
+ <TrashIcon />
+ </button>
+ </>
+ )}
+ </td>
+ </tr>
+ );
+ })}
+ </tbody>
+ </table>
+ )}
+ </div>
+ )}
+
+ {subTab === 'images' && (
+ <div className="images-list">
+ {images.length === 0 ? (
+ <div className="empty-list">No images found on this server.</div>
+ ) : (
+ <table className="data-table">
+ <thead>
+ <tr>
+ <th>Repository</th>
+ <th>Tag</th>
+ <th>Image ID</th>
+ <th>Size</th>
+ <th>Created</th>
+ </tr>
+ </thead>
+ <tbody>
+ {images.map(image => (
+ <tr key={image.id}>
+ <td>{image.repository || '<none>'}</td>
+ <td>{image.tag || '<none>'}</td>
+ <td className="mono">{image.id?.substring(0, 12)}</td>
+ <td>{image.size}</td>
+ <td>{image.created}</td>
+ </tr>
+ ))}
+ </tbody>
+ </table>
+ )}
+ </div>
+ )}
+ </div>
+ );
+};
+
+const MetricsTab = ({ serverId, metrics }) => {
+ if (!metrics) {
+ return (
+ <div className="offline-notice">
+ <OfflineIcon />
+ <h4>No Metrics Available</h4>
+ <p>Metrics are only available when the server is online.</p>
+ </div>
+ );
+ }
+
+ return (
+ <div className="metrics-tab">
+ <div className="metrics-grid">
+ <div className="metric-card large">
+ <h3>CPU Usage</h3>
+ <div className="metric-gauge">
+ <CircularGauge value={metrics.cpu_percent || 0} color="#6366F1" />
+ </div>
+ <div className="metric-details">
+ <div className="detail-item">
+ <span>Load Average</span>
+ <span>{metrics.load_avg?.join(', ') || 'N/A'}</span>
+ </div>
+ </div>
+ </div>
+
+ <div className="metric-card large">
+ <h3>Memory Usage</h3>
+ <div className="metric-gauge">
+ <CircularGauge value={metrics.memory_percent || 0} color="#10B981" />
+ </div>
+ <div className="metric-details">
+ <div className="detail-item">
+ <span>Used</span>
+ <span>{formatBytes(metrics.memory_used)}</span>
+ </div>
+ <div className="detail-item">
+ <span>Total</span>
+ <span>{formatBytes(metrics.memory_total)}</span>
+ </div>
+ </div>
+ </div>
+
+ <div className="metric-card large">
+ <h3>Disk Usage</h3>
+ <div className="metric-gauge">
+ <CircularGauge value={metrics.disk_percent || 0} color="#F59E0B" />
+ </div>
+ <div className="metric-details">
+ <div className="detail-item">
+ <span>Used</span>
+ <span>{formatBytes(metrics.disk_used)}</span>
+ </div>
+ <div className="detail-item">
+ <span>Total</span>
+ <span>{formatBytes(metrics.disk_total)}</span>
+ </div>
+ </div>
+ </div>
+
+ <div className="metric-card">
+ <h3>Network I/O</h3>
+ <div className="network-stats">
+ <div className="net-stat">
+ <UploadIcon />
+ <span>Upload</span>
+ <span className="value">{formatBytes(metrics.network_sent)}/s</span>
+ </div>
+ <div className="net-stat">
+ <DownloadIcon />
+ <span>Download</span>
+ <span className="value">{formatBytes(metrics.network_recv)}/s</span>
+ </div>
+ </div>
+ </div>
+
+ <div className="metric-card">
+ <h3>Docker</h3>
+ <div className="docker-stats">
+ <div className="docker-stat">
+ <span>Containers</span>
+ <span className="value">{metrics.container_count || 0}</span>
+ </div>
+ <div className="docker-stat">
+ <span>Running</span>
+ <span className="value">{metrics.container_running || 0}</span>
+ </div>
+ </div>
+ </div>
+ </div>
+ </div>
+ );
+};
+
+const CircularGauge = ({ value, color }) => {
+ const safeValue = Math.min(Math.max(value || 0, 0), 100);
+ const circumference = 2 * Math.PI * 45;
+ const offset = circumference - (safeValue / 100) * circumference;
+
+ return (
+ <svg className="circular-gauge" viewBox="0 0 100 100">
+ <circle className="gauge-bg" cx="50" cy="50" r="45" />
+ <circle
+ className="gauge-fill"
+ cx="50"
+ cy="50"
+ r="45"
+ style={{
+ strokeDasharray: circumference,
+ strokeDashoffset: offset,
+ stroke: safeValue > 80 ? '#EF4444' : color
+ }}
+ />
+ <text x="50" y="50" className="gauge-text">
+ {safeValue.toFixed(0)}%
+ </text>
+ </svg>
+ );
+};
+
+const SettingsTab = ({ server, onUpdate, onRegenerateToken }) => {
+ const [formData, setFormData] = useState({
+ name: server.name || '',
+ description: server.description || '',
+ hostname: server.hostname || '',
+ ip_address: server.ip_address || '',
+ group_id: server.group_id || ''
+ });
+ const [groups, setGroups] = useState([]);
+ const [loading, setLoading] = useState(false);
+ const toast = useToast();
+
+ useEffect(() => {
+ loadGroups();
+ }, []);
+
+ async function loadGroups() {
+ try {
+ const data = await api.getServerGroups();
+ setGroups(data.groups || []);
+ } catch (err) {
+ console.error('Failed to load groups:', err);
+ }
+ }
+
+ async function handleSubmit(e) {
+ e.preventDefault();
+ setLoading(true);
+
+ try {
+ await api.updateServer(server.id, formData);
+ toast.success('Server updated successfully');
+ onUpdate();
+ } catch (err) {
+ toast.error(err.message || 'Failed to update server');
+ } finally {
+ setLoading(false);
+ }
+ }
+
+ function handleChange(e) {
+ const { name, value } = e.target;
+ setFormData(prev => ({ ...prev, [name]: value }));
+ }
+
+ return (
+ <div className="settings-tab">
+ <form onSubmit={handleSubmit} className="settings-form">
+ <div className="form-section">
+ <h3>Basic Information</h3>
+
+ <div className="form-group">
+ <label>Server Name</label>
+ <input
+ type="text"
+ name="name"
+ value={formData.name}
+ onChange={handleChange}
+ required
+ />
+ </div>
+
+ <div className="form-group">
+ <label>Description</label>
+ <textarea
+ name="description"
+ value={formData.description}
+ onChange={handleChange}
+ rows={3}
+ />
+ </div>
+
+ <div className="form-row">
+ <div className="form-group">
+ <label>Hostname</label>
+ <input
+ type="text"
+ name="hostname"
+ value={formData.hostname}
+ onChange={handleChange}
+ />
+ </div>
+ <div className="form-group">
+ <label>IP Address</label>
+ <input
+ type="text"
+ name="ip_address"
+ value={formData.ip_address}
+ onChange={handleChange}
+ />
+ </div>
+ </div>
+
+ <div className="form-group">
+ <label>Group</label>
+ <select name="group_id" value={formData.group_id} onChange={handleChange}>
+ <option value="">No Group</option>
+ {groups.map(group => (
+ <option key={group.id} value={group.id}>{group.name}</option>
+ ))}
+ </select>
+ </div>
+
+ <button type="submit" className="btn btn-primary" disabled={loading}>
+ {loading ? 'Saving...' : 'Save Changes'}
+ </button>
+ </div>
+ </form>
+
+ <div className="form-section">
+ <h3>Agent Registration</h3>
+ <p className="section-description">
+ If you need to reinstall the agent or connect from a different machine,
+ generate a new registration token.
+ </p>
+ <button className="btn btn-secondary" onClick={onRegenerateToken}>
+ <RefreshIcon /> Generate New Token
+ </button>
+ </div>
+
+ <div className="form-section danger-zone">
+ <h3>Danger Zone</h3>
+ <p className="section-description">
+ Removing this server will disconnect the agent and delete all associated data.
+ </p>
+ <button className="btn btn-danger">
+ <TrashIcon /> Remove Server
+ </button>
+ </div>
+ </div>
+ );
+};
+
+// Helper function
+function formatBytes(bytes) {
+ if (!bytes) return 'N/A';
+ const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+ const i = Math.floor(Math.log(bytes) / Math.log(1024));
+ return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${sizes[i]}`;
+}
+
+// Icons
+const RefreshIcon = () => (
+ <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+ <polyline points="23 4 23 10 17 10"/>
+ <path d="M20.49 15a9 9 0 1 1-2.12-9.36L23 10"/>
+ </svg>
+);
+
+const TrashIcon = () => (
+ <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+ <polyline points="3 6 5 6 21 6"/>
+ <path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/>
+ </svg>
+);
+
+const OfflineIcon = () => (
+ <svg width="48" height="48" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.5">
+ <line x1="1" y1="1" x2="23" y2="23"/>
+ <path d="M16.72 11.06A10.94 10.94 0 0 1 19 12.55"/>
+ <path d="M5 12.55a10.94 10.94 0 0 1 5.17-2.39"/>
+ <path d="M10.71 5.05A16 16 0 0 1 22.58 9"/>
+ <path d="M1.42 9a15.91 15.91 0 0 1 4.7-2.88"/>
+ <path d="M8.53 16.11a6 6 0 0 1 6.95 0"/>
+ <line x1="12" y1="20" x2="12.01" y2="20"/>
+ </svg>
+);
+
+const StopIcon = () => (
+ <svg width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
+ <rect x="6" y="6" width="12" height="12"/>
+ </svg>
+);
+
+const PlayIcon = () => (
+ <svg width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
+ <polygon points="5 3 19 12 5 21 5 3"/>
+ </svg>
+);
+
+const UploadIcon = () => (
+ <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+ <polyline points="17 11 12 6 7 11"/>
+ <line x1="12" y1="6" x2="12" y2="18"/>
+ </svg>
+);
+
+const DownloadIcon = () => (
+ <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+ <polyline points="7 13 12 18 17 13"/>
+ <line x1="12" y1="18" x2="12" y2="6"/>
+ </svg>
+);
+
+export default ServerDetail;
diff --git a/frontend/src/pages/Servers.jsx b/frontend/src/pages/Servers.jsx
new file mode 100644
index 00000000..178193b2
--- /dev/null
+++ b/frontend/src/pages/Servers.jsx
@@ -0,0 +1,777 @@
+import React, { useState, useEffect } from 'react';
+import { Link } from 'react-router-dom';
+import api from '../services/api';
+import { useToast } from '../contexts/ToastContext';
+
+const Servers = () => {
+ const [servers, setServers] = useState([]);
+ const [groups, setGroups] = useState([]);
+ const [loading, setLoading] = useState(true);
+ const [showAddModal, setShowAddModal] = useState(false);
+ const [showGroupModal, setShowGroupModal] = useState(false);
+ const [selectedGroup, setSelectedGroup] = useState('all');
+ const [searchTerm, setSearchTerm] = useState('');
+ const toast = useToast();
+
+ useEffect(() => {
+ loadData();
+ }, []);
+
+ async function loadData() {
+ setLoading(true);
+ try {
+ const [serversData, groupsData] = await Promise.all([
+ api.getServers(),
+ api.getServerGroups()
+ ]);
+ setServers(serversData.servers || []);
+ setGroups(groupsData.groups || []);
+ } catch (err) {
+ console.error('Failed to load servers:', err);
+ toast.error('Failed to load servers');
+ } finally {
+ setLoading(false);
+ }
+ }
+
+ async function handleDeleteServer(serverId) {
+ if (!confirm('Are you sure you want to remove this server?')) return;
+
+ try {
+ await api.deleteServer(serverId);
+ toast.success('Server removed successfully');
+ loadData();
+ } catch (err) {
+ toast.error(err.message || 'Failed to remove server');
+ }
+ }
+
+ async function handlePingServer(serverId) {
+ try {
+ const result = await api.pingServer(serverId);
+ if (result.success) {
+ toast.success(`Server responded in ${result.latency}ms`);
+ } else {
+ toast.error('Server did not respond');
+ }
+ loadData();
+ } catch (err) {
+ toast.error('Failed to ping server');
+ }
+ }
+
+ const filteredServers = servers.filter(server => {
+ const matchesGroup = selectedGroup === 'all' || server.group_id === selectedGroup;
+ const matchesSearch = !searchTerm ||
+ server.name?.toLowerCase().includes(searchTerm.toLowerCase()) ||
+ server.hostname?.toLowerCase().includes(searchTerm.toLowerCase()) ||
+ server.ip_address?.toLowerCase().includes(searchTerm.toLowerCase());
+ return matchesGroup && matchesSearch;
+ });
+
+ const stats = {
+ total: servers.length,
+ online: servers.filter(s => s.status === 'online').length,
+ offline: servers.filter(s => s.status === 'offline').length,
+ connecting: servers.filter(s => s.status === 'connecting').length
+ };
+
+ if (loading) {
+ return <div className="loading">Loading servers...</div>;
+ }
+
+ return (
+ <div className="servers-page">
+ <div className="page-header">
+ <div className="page-header-content">
+ <h1>Servers</h1>
+ <p className="page-description">Manage your connected servers and agents</p>
+ </div>
+ <div className="page-header-actions">
+ <button className="btn btn-secondary" onClick={() => setShowGroupModal(true)}>
+ <FolderIcon />
+ Manage Groups
+ </button>
+ <button className="btn btn-primary" onClick={() => setShowAddModal(true)}>
+ <PlusIcon />
+ Add Server
+ </button>
+ </div>
+ </div>
+
+ <div className="servers-stats">
+ <div className="stat-card">
+ <div className="stat-icon total">
+ <ServerIcon />
+ </div>
+ <div className="stat-content">
+ <div className="stat-value">{stats.total}</div>
+ <div className="stat-label">Total Servers</div>
+ </div>
+ </div>
+ <div className="stat-card">
+ <div className="stat-icon online">
+ <CheckCircleIcon />
+ </div>
+ <div className="stat-content">
+ <div className="stat-value">{stats.online}</div>
+ <div className="stat-label">Online</div>
+ </div>
+ </div>
+ <div className="stat-card">
+ <div className="stat-icon offline">
+ <XCircleIcon />
+ </div>
+ <div className="stat-content">
+ <div className="stat-value">{stats.offline}</div>
+ <div className="stat-label">Offline</div>
+ </div>
+ </div>
+ <div className="stat-card">
+ <div className="stat-icon connecting">
+ <RefreshIcon />
+ </div>
+ <div className="stat-content">
+ <div className="stat-value">{stats.connecting}</div>
+ <div className="stat-label">Connecting</div>
+ </div>
+ </div>
+ </div>
+
+ <div className="servers-toolbar">
+ <div className="search-box">
+ <SearchIcon />
+ <input
+ type="text"
+ placeholder="Search servers..."
+ value={searchTerm}
+ onChange={(e) => setSearchTerm(e.target.value)}
+ />
+ </div>
+ <div className="group-filter">
+ <select value={selectedGroup} onChange={(e) => setSelectedGroup(e.target.value)}>
+ <option value="all">All Groups</option>
+ {groups.map(group => (
+ <option key={group.id} value={group.id}>{group.name}</option>
+ ))}
+ <option value="ungrouped">Ungrouped</option>
+ </select>
+ </div>
+ </div>
+
+ {filteredServers.length === 0 ? (
+ <div className="empty-state">
+ <ServerIcon className="empty-icon" />
+ <h3>No servers found</h3>
+ <p>
+ {servers.length === 0
+ ? 'Add your first server to start managing remote infrastructure.'
+ : 'No servers match your current filters.'}
+ </p>
+ {servers.length === 0 && (
+ <button className="btn btn-primary" onClick={() => setShowAddModal(true)}>
+ <PlusIcon /> Add Server
+ </button>
+ )}
+ </div>
+ ) : (
+ <div className="servers-grid">
+ {filteredServers.map(server => (
+ <ServerCard
+ key={server.id}
+ server={server}
+ onDelete={() => handleDeleteServer(server.id)}
+ onPing={() => handlePingServer(server.id)}
+ />
+ ))}
+ </div>
+ )}
+
+ {showAddModal && (
+ <AddServerModal
+ groups={groups}
+ onClose={() => setShowAddModal(false)}
+ onCreated={() => {
+ setShowAddModal(false);
+ loadData();
+ }}
+ />
+ )}
+
+ {showGroupModal && (
+ <ManageGroupsModal
+ groups={groups}
+ onClose={() => setShowGroupModal(false)}
+ onUpdated={loadData}
+ />
+ )}
+ </div>
+ );
+};
+
+const ServerCard = ({ server, onDelete, onPing }) => {
+ const statusColors = {
+ online: '#10B981',
+ offline: '#EF4444',
+ connecting: '#F59E0B',
+ pending: '#6B7280'
+ };
+
+ const formatLastSeen = (timestamp) => {
+ if (!timestamp) return 'Never';
+ const date = new Date(timestamp);
+ const now = new Date();
+ const diff = (now - date) / 1000;
+
+ if (diff < 60) return 'Just now';
+ if (diff < 3600) return `${Math.floor(diff / 60)}m ago`;
+ if (diff < 86400) return `${Math.floor(diff / 3600)}h ago`;
+ return date.toLocaleDateString();
+ };
+
+ return (
+ <div className={`server-card ${server.status}`}>
+ <div className="server-card-header">
+ <div className="server-status-indicator" style={{ backgroundColor: statusColors[server.status] || '#6B7280' }} />
+ <div className="server-info">
+ <h3 className="server-name">{server.name}</h3>
+ <span className="server-hostname">{server.hostname || server.ip_address}</span>
+ </div>
+ <div className="server-actions-dropdown">
+ <button className="btn-icon" title="Actions">
+ <MoreIcon />
+ </button>
+ </div>
+ </div>
+
+ <div className="server-card-body">
+ <div className="server-meta">
+ <div className="meta-item">
+ <span className="meta-label">OS</span>
+ <span className="meta-value">{server.os_type || 'Unknown'}</span>
+ </div>
+ <div className="meta-item">
+ <span className="meta-label">Agent</span>
+ <span className="meta-value">{server.agent_version || 'Not installed'}</span>
+ </div>
+ <div className="meta-item">
+ <span className="meta-label">Docker</span>
+ <span className="meta-value">{server.docker_version || 'N/A'}</span>
+ </div>
+ <div className="meta-item">
+ <span className="meta-label">Last Seen</span>
+ <span className="meta-value">{formatLastSeen(server.last_seen)}</span>
+ </div>
+ </div>
+
+ {server.metrics && server.status === 'online' && (
+ <div className="server-metrics-mini">
+ <div className="metric-bar">
+ <span className="metric-label">CPU</span>
+ <div className="bar-track">
+ <div
+ className="bar-fill cpu"
+ style={{ width: `${server.metrics.cpu_percent || 0}%` }}
+ />
+ </div>
+ <span className="metric-value">{(server.metrics.cpu_percent || 0).toFixed(0)}%</span>
+ </div>
+ <div className="metric-bar">
+ <span className="metric-label">RAM</span>
+ <div className="bar-track">
+ <div
+ className="bar-fill memory"
+ style={{ width: `${server.metrics.memory_percent || 0}%` }}
+ />
+ </div>
+ <span className="metric-value">{(server.metrics.memory_percent || 0).toFixed(0)}%</span>
+ </div>
+ <div className="metric-bar">
+ <span className="metric-label">Disk</span>
+ <div className="bar-track">
+ <div
+ className="bar-fill disk"
+ style={{ width: `${server.metrics.disk_percent || 0}%` }}
+ />
+ </div>
+ <span className="metric-value">{(server.metrics.disk_percent || 0).toFixed(0)}%</span>
+ </div>
+ </div>
+ )}
+
+ {server.group_name && (
+ <div className="server-group-badge">
+ <FolderIcon size={12} />
+ {server.group_name}
+ </div>
+ )}
+ </div>
+
+ <div className="server-card-footer">
+ <Link to={`/servers/${server.id}`} className="btn btn-sm btn-secondary">
+ <EyeIcon /> Details
+ </Link>
+ <button className="btn btn-sm btn-secondary" onClick={onPing} title="Ping Server">
+ <RefreshIcon />
+ </button>
+ <Link to={`/servers/${server.id}/docker`} className="btn btn-sm btn-primary">
+ <DockerIcon /> Docker
+ </Link>
+ </div>
+ </div>
+ );
+};
+
+const AddServerModal = ({ groups, onClose, onCreated }) => {
+ const [step, setStep] = useState(1);
+ const [formData, setFormData] = useState({
+ name: '',
+ description: '',
+ group_id: '',
+ hostname: '',
+ ip_address: '',
+ permissions: ['docker:read', 'docker:write', 'system:read']
+ });
+ const [registrationData, setRegistrationData] = useState(null);
+ const [loading, setLoading] = useState(false);
+ const [error, setError] = useState('');
+ const toast = useToast();
+
+ async function handleCreateServer(e) {
+ e.preventDefault();
+ setError('');
+ setLoading(true);
+
+ try {
+ const result = await api.createServer(formData);
+ setRegistrationData(result);
+ setStep(2);
+ } catch (err) {
+ setError(err.message || 'Failed to create server');
+ } finally {
+ setLoading(false);
+ }
+ }
+
+ function handleChange(e) {
+ const { name, value } = e.target;
+ setFormData(prev => ({ ...prev, [name]: value }));
+ }
+
+ function copyToClipboard(text) {
+ navigator.clipboard.writeText(text);
+ toast.success('Copied to clipboard');
+ }
+
+ const linuxInstallScript = registrationData ? `curl -fsSL https://your-server/api/v1/servers/install.sh | sudo bash -s -- \\
+ --server-url "${window.location.origin}" \\
+ --token "${registrationData.registration_token}"` : '';
+
+ const windowsInstallScript = registrationData ? `irm https://your-server/api/v1/servers/install.ps1 | iex
+Install-ServerKitAgent -ServerUrl "${window.location.origin}" -Token "${registrationData.registration_token}"` : '';
+
+ return (
+ <div className="modal-overlay" onClick={onClose}>
+ <div className="modal modal-lg" onClick={e => e.stopPropagation()}>
+ <div className="modal-header">
+ <h2>{step === 1 ? 'Add Server' : 'Install Agent'}</h2>
+ <button className="modal-close" onClick={onClose}>&times;</button>
+ </div>
+
+ {step === 1 ? (
+ <form onSubmit={handleCreateServer}>
+ {error && <div className="error-message">{error}</div>}
+
+ <div className="form-group">
+ <label>Server Name *</label>
+ <input
+ type="text"
+ name="name"
+ value={formData.name}
+ onChange={handleChange}
+ placeholder="My Production Server"
+ required
+ />
+ </div>
+
+ <div className="form-group">
+ <label>Description</label>
+ <textarea
+ name="description"
+ value={formData.description}
+ onChange={handleChange}
+ placeholder="Optional description..."
+ rows={2}
+ />
+ </div>
+
+ <div className="form-row">
+ <div className="form-group">
+ <label>Hostname</label>
+ <input
+ type="text"
+ name="hostname"
+ value={formData.hostname}
+ onChange={handleChange}
+ placeholder="server.example.com"
+ />
+ </div>
+ <div className="form-group">
+ <label>IP Address</label>
+ <input
+ type="text"
+ name="ip_address"
+ value={formData.ip_address}
+ onChange={handleChange}
+ placeholder="192.168.1.100"
+ />
+ </div>
+ </div>
+
+ <div className="form-group">
+ <label>Group</label>
+ <select name="group_id" value={formData.group_id} onChange={handleChange}>
+ <option value="">No Group</option>
+ {groups.map(group => (
+ <option key={group.id} value={group.id}>{group.name}</option>
+ ))}
+ </select>
+ </div>
+
+ <div className="form-group">
+ <label>Permissions</label>
+ <div className="permissions-grid">
+ {[
+ { key: 'docker:read', label: 'Docker (Read)' },
+ { key: 'docker:write', label: 'Docker (Write)' },
+ { key: 'system:read', label: 'System Metrics' },
+ { key: 'system:exec', label: 'Remote Execution' }
+ ].map(perm => (
+ <label key={perm.key} className="permission-checkbox">
+ <input
+ type="checkbox"
+ checked={formData.permissions.includes(perm.key)}
+ onChange={(e) => {
+ const newPerms = e.target.checked
+ ? [...formData.permissions, perm.key]
+ : formData.permissions.filter(p => p !== perm.key);
+ setFormData(prev => ({ ...prev, permissions: newPerms }));
+ }}
+ />
+ {perm.label}
+ </label>
+ ))}
+ </div>
+ </div>
+
+ <div className="modal-actions">
+ <button type="button" className="btn btn-secondary" onClick={onClose}>
+ Cancel
+ </button>
+ <button type="submit" className="btn btn-primary" disabled={loading}>
+ {loading ? 'Creating...' : 'Create & Get Install Script'}
+ </button>
+ </div>
+ </form>
+ ) : (
+ <div className="install-instructions">
+ <div className="success-banner">
+ <CheckCircleIcon />
+ <span>Server created! Install the agent to connect.</span>
+ </div>
+
+ <div className="install-tabs">
+ <InstallTab
+ title="Linux / macOS"
+ icon={<TerminalIcon />}
+ script={linuxInstallScript}
+ onCopy={() => copyToClipboard(linuxInstallScript)}
+ />
+ <InstallTab
+ title="Windows (PowerShell)"
+ icon={<WindowsIcon />}
+ script={windowsInstallScript}
+ onCopy={() => copyToClipboard(windowsInstallScript)}
+ />
+ </div>
+
+ <div className="install-info">
+ <h4>What happens next?</h4>
+ <ol>
+ <li>Run the install script on your server</li>
+ <li>The agent will download and configure automatically</li>
+ <li>Once connected, the server will appear as "Online"</li>
+ </ol>
+ <p className="text-muted">
+ The registration token expires in 1 hour. After that, you'll need to generate a new one.
+ </p>
+ </div>
+
+ <div className="modal-actions">
+ <button className="btn btn-primary" onClick={onCreated}>
+ Done
+ </button>
+ </div>
+ </div>
+ )}
+ </div>
+ </div>
+ );
+};
+
+const InstallTab = ({ title, icon, script, onCopy }) => {
+ return (
+ <div className="install-tab">
+ <div className="install-tab-header">
+ {icon}
+ <span>{title}</span>
+ <button className="btn btn-sm btn-secondary" onClick={onCopy}>
+ <CopyIcon /> Copy
+ </button>
+ </div>
+ <pre className="install-script">{script}</pre>
+ </div>
+ );
+};
+
+const ManageGroupsModal = ({ groups, onClose, onUpdated }) => {
+ const [groupList, setGroupList] = useState(groups);
+ const [newGroupName, setNewGroupName] = useState('');
+ const [editingGroup, setEditingGroup] = useState(null);
+ const [loading, setLoading] = useState(false);
+ const toast = useToast();
+
+ async function handleCreateGroup(e) {
+ e.preventDefault();
+ if (!newGroupName.trim()) return;
+
+ setLoading(true);
+ try {
+ await api.createServerGroup({ name: newGroupName.trim() });
+ setNewGroupName('');
+ toast.success('Group created');
+ onUpdated();
+ const data = await api.getServerGroups();
+ setGroupList(data.groups || []);
+ } catch (err) {
+ toast.error(err.message || 'Failed to create group');
+ } finally {
+ setLoading(false);
+ }
+ }
+
+ async function handleUpdateGroup(groupId, newName) {
+ try {
+ await api.updateServerGroup(groupId, { name: newName });
+ toast.success('Group updated');
+ setEditingGroup(null);
+ onUpdated();
+ const data = await api.getServerGroups();
+ setGroupList(data.groups || []);
+ } catch (err) {
+ toast.error(err.message || 'Failed to update group');
+ }
+ }
+
+ async function handleDeleteGroup(groupId) {
+ if (!confirm('Delete this group? Servers in this group will become ungrouped.')) return;
+
+ try {
+ await api.deleteServerGroup(groupId);
+ toast.success('Group deleted');
+ onUpdated();
+ const data = await api.getServerGroups();
+ setGroupList(data.groups || []);
+ } catch (err) {
+ toast.error(err.message || 'Failed to delete group');
+ }
+ }
+
+ return (
+ <div className="modal-overlay" onClick={onClose}>
+ <div className="modal" onClick={e => e.stopPropagation()}>
+ <div className="modal-header">
+ <h2>Manage Server Groups</h2>
+ <button className="modal-close" onClick={onClose}>&times;</button>
+ </div>
+
+ <form onSubmit={handleCreateGroup} className="group-form">
+ <input
+ type="text"
+ value={newGroupName}
+ onChange={(e) => setNewGroupName(e.target.value)}
+ placeholder="New group name..."
+ disabled={loading}
+ />
+ <button type="submit" className="btn btn-primary" disabled={loading || !newGroupName.trim()}>
+ <PlusIcon /> Add
+ </button>
+ </form>
+
+ <div className="groups-list">
+ {groupList.length === 0 ? (
+ <div className="empty-groups">No groups created yet</div>
+ ) : (
+ groupList.map(group => (
+ <div key={group.id} className="group-item">
+ {editingGroup === group.id ? (
+ <input
+ type="text"
+ defaultValue={group.name}
+ onBlur={(e) => handleUpdateGroup(group.id, e.target.value)}
+ onKeyDown={(e) => {
+ if (e.key === 'Enter') handleUpdateGroup(group.id, e.target.value);
+ if (e.key === 'Escape') setEditingGroup(null);
+ }}
+ autoFocus
+ />
+ ) : (
+ <>
+ <span className="group-name">
+ <FolderIcon size={14} />
+ {group.name}
+ </span>
+ <span className="group-count">{group.server_count || 0} servers</span>
+ <div className="group-actions">
+ <button
+ className="btn-icon"
+ onClick={() => setEditingGroup(group.id)}
+ title="Edit"
+ >
+ <EditIcon />
+ </button>
+ <button
+ className="btn-icon danger"
+ onClick={() => handleDeleteGroup(group.id)}
+ title="Delete"
+ >
+ <TrashIcon />
+ </button>
+ </div>
+ </>
+ )}
+ </div>
+ ))
+ )}
+ </div>
+
+ <div className="modal-actions">
+ <button className="btn btn-primary" onClick={onClose}>Done</button>
+ </div>
+ </div>
+ </div>
+ );
+};
+
+// Icons
+const ServerIcon = ({ size = 24, className = '' }) => (
+ <svg className={className} width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+ <rect x="2" y="2" width="20" height="8" rx="2" ry="2"/>
+ <rect x="2" y="14" width="20" height="8" rx="2" ry="2"/>
+ <line x1="6" y1="6" x2="6.01" y2="6"/>
+ <line x1="6" y1="18" x2="6.01" y2="18"/>
+ </svg>
+);
+
+const PlusIcon = () => (
+ <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+ <line x1="12" y1="5" x2="12" y2="19"/>
+ <line x1="5" y1="12" x2="19" y2="12"/>
+ </svg>
+);
+
+const FolderIcon = ({ size = 16 }) => (
+ <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+ <path d="M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z"/>
+ </svg>
+);
+
+const SearchIcon = () => (
+ <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+ <circle cx="11" cy="11" r="8"/>
+ <line x1="21" y1="21" x2="16.65" y2="16.65"/>
+ </svg>
+);
+
+const CheckCircleIcon = () => (
+ <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+ <path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"/>
+ <polyline points="22 4 12 14.01 9 11.01"/>
+ </svg>
+);
+
+const XCircleIcon = () => (
+ <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+ <circle cx="12" cy="12" r="10"/>
+ <line x1="15" y1="9" x2="9" y2="15"/>
+ <line x1="9" y1="9" x2="15" y2="15"/>
+ </svg>
+);
+
+const RefreshIcon = () => (
+ <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+ <polyline points="23 4 23 10 17 10"/>
+ <path d="M20.49 15a9 9 0 1 1-2.12-9.36L23 10"/>
+ </svg>
+);
+
+const MoreIcon = () => (
+ <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+ <circle cx="12" cy="12" r="1"/>
+ <circle cx="19" cy="12" r="1"/>
+ <circle cx="5" cy="12" r="1"/>
+ </svg>
+);
+
+const EyeIcon = () => (
+ <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+ <path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"/>
+ <circle cx="12" cy="12" r="3"/>
+ </svg>
+);
+
+const DockerIcon = () => (
+ <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+ <rect x="2" y="7" width="5" height="5" rx="1"/>
+ <rect x="9" y="7" width="5" height="5" rx="1"/>
+ <rect x="16" y="7" width="5" height="5" rx="1"/>
+ <rect x="2" y="14" width="5" height="5" rx="1"/>
+ <rect x="9" y="14" width="5" height="5" rx="1"/>
+ </svg>
+);
+
+const TerminalIcon = () => (
+ <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+ <polyline points="4 17 10 11 4 5"/>
+ <line x1="12" y1="19" x2="20" y2="19"/>
+ </svg>
+);
+
+const WindowsIcon = () => (
+ <svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor">
+ <path d="M0 3.449L9.75 2.1v9.451H0m10.949-9.602L24 0v11.4H10.949M0 12.6h9.75v9.451L0 20.699M10.949 12.6H24V24l-12.9-1.801"/>
+ </svg>
+);
+
+const CopyIcon = () => (
+ <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+ <rect x="9" y="9" width="13" height="13" rx="2" ry="2"/>
+ <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/>
+ </svg>
+);
+
+const EditIcon = () => (
+ <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+ <path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"/>
+ <path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z"/>
+ </svg>
+);
+
+const TrashIcon = () => (
+ <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+ <polyline points="3 6 5 6 21 6"/>
+ <path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/>
+ </svg>
+);
+
+export default Servers;
diff --git a/frontend/src/services/api.js b/frontend/src/services/api.js
index fb43e08d..83310ce7 100644
--- a/frontend/src/services/api.js
+++ b/frontend/src/services/api.js
@@ -2548,6 +2548,165 @@ class ApiService {
method: 'POST'
});
}
+
+ // ========================================
+ // Servers (Multi-Server Management) endpoints
+ // ========================================
+ async getServers() {
+ return this.request('/servers');
+ }
+
+ async getServer(id) {
+ return this.request(`/servers/${id}`);
+ }
+
+ async createServer(data) {
+ return this.request('/servers', {
+ method: 'POST',
+ body: data
+ });
+ }
+
+ async updateServer(id, data) {
+ return this.request(`/servers/${id}`, {
+ method: 'PUT',
+ body: data
+ });
+ }
+
+ async deleteServer(id) {
+ return this.request(`/servers/${id}`, {
+ method: 'DELETE'
+ });
+ }
+
+ async getServerStatus(id) {
+ return this.request(`/servers/${id}/status`);
+ }
+
+ async getServerMetrics(id) {
+ return this.request(`/servers/${id}/metrics`);
+ }
+
+ async pingServer(id) {
+ return this.request(`/servers/${id}/ping`, {
+ method: 'POST'
+ });
+ }
+
+ // Server Registration
+ async generateRegistrationToken(serverId) {
+ return this.request(`/servers/${serverId}/registration-token`, {
+ method: 'POST'
+ });
+ }
+
+ async registerServer(registrationData) {
+ return this.request('/servers/register', {
+ method: 'POST',
+ body: registrationData
+ });
+ }
+
+ // Server Groups
+ async getServerGroups() {
+ return this.request('/servers/groups');
+ }
+
+ async createServerGroup(data) {
+ return this.request('/servers/groups', {
+ method: 'POST',
+ body: data
+ });
+ }
+
+ async updateServerGroup(id, data) {
+ return this.request(`/servers/groups/${id}`, {
+ method: 'PUT',
+ body: data
+ });
+ }
+
+ async deleteServerGroup(id) {
+ return this.request(`/servers/groups/${id}`, {
+ method: 'DELETE'
+ });
+ }
+
+ // Remote Docker Operations (via agent)
+ async getRemoteContainers(serverId, all = false) {
+ return this.request(`/servers/${serverId}/docker/containers?all=${all}`);
+ }
+
+ async getRemoteContainer(serverId, containerId) {
+ return this.request(`/servers/${serverId}/docker/containers/${containerId}`);
+ }
+
+ async startRemoteContainer(serverId, containerId) {
+ return this.request(`/servers/${serverId}/docker/containers/${containerId}/start`, {
+ method: 'POST'
+ });
+ }
+
+ async stopRemoteContainer(serverId, containerId) {
+ return this.request(`/servers/${serverId}/docker/containers/${containerId}/stop`, {
+ method: 'POST'
+ });
+ }
+
+ async restartRemoteContainer(serverId, containerId) {
+ return this.request(`/servers/${serverId}/docker/containers/${containerId}/restart`, {
+ method: 'POST'
+ });
+ }
+
+ async removeRemoteContainer(serverId, containerId, force = false) {
+ return this.request(`/servers/${serverId}/docker/containers/${containerId}?force=${force}`, {
+ method: 'DELETE'
+ });
+ }
+
+ async getRemoteContainerStats(serverId, containerId) {
+ return this.request(`/servers/${serverId}/docker/containers/${containerId}/stats`);
+ }
+
+ async getRemoteImages(serverId) {
+ return this.request(`/servers/${serverId}/docker/images`);
+ }
+
+ async pullRemoteImage(serverId, image) {
+ return this.request(`/servers/${serverId}/docker/images/pull`, {
+ method: 'POST',
+ body: { image }
+ });
+ }
+
+ async removeRemoteImage(serverId, imageId, force = false) {
+ return this.request(`/servers/${serverId}/docker/images/${imageId}?force=${force}`, {
+ method: 'DELETE'
+ });
+ }
+
+ async getRemoteVolumes(serverId) {
+ return this.request(`/servers/${serverId}/docker/volumes`);
+ }
+
+ async getRemoteNetworks(serverId) {
+ return this.request(`/servers/${serverId}/docker/networks`);
+ }
+
+ async getRemoteSystemMetrics(serverId) {
+ return this.request(`/servers/${serverId}/system/metrics`);
+ }
+
+ async getRemoteSystemInfo(serverId) {
+ return this.request(`/servers/${serverId}/system/info`);
+ }
+
+ // Get available servers for Docker operations
+ async getAvailableServers() {
+ return this.request('/servers/available');
+ }
}
export const api = new ApiService();
diff --git a/frontend/src/styles/main.less b/frontend/src/styles/main.less
index a37618ef..dc1208c0 100644
--- a/frontend/src/styles/main.less
+++ b/frontend/src/styles/main.less
@@ -72,3 +72,4 @@
@import 'pages/_templates';
@import 'pages/_workflow';
@import 'pages/_git';
+@import 'pages/_servers';
diff --git a/frontend/src/styles/pages/_docker.less b/frontend/src/styles/pages/_docker.less
index 8dcd3e8f..5d2368e3 100644
--- a/frontend/src/styles/pages/_docker.less
+++ b/frontend/src/styles/pages/_docker.less
@@ -31,9 +31,50 @@
.docker-page-actions {
display: flex;
+ align-items: center;
gap: @space-3;
}
+// Server Selector
+.server-selector {
+ display: flex;
+ align-items: center;
+ gap: @space-2;
+ background: @bg-card;
+ border: 1px solid @border-subtle;
+ border-radius: @radius-md;
+ padding: @space-2 @space-3;
+ margin-right: @space-2;
+
+ svg {
+ color: @text-tertiary;
+ flex-shrink: 0;
+ }
+
+ select {
+ background: transparent;
+ border: none;
+ color: @text-primary;
+ font-size: @font-size-sm;
+ cursor: pointer;
+ padding-right: @space-4;
+ min-width: 140px;
+
+ &:focus {
+ outline: none;
+ }
+
+ option {
+ background: @bg-card;
+ color: @text-primary;
+ }
+
+ option:disabled {
+ color: @text-tertiary;
+ }
+ }
+}
+
// Stats Row
.docker-stats-row {
display: grid;
diff --git a/frontend/src/styles/pages/_servers.less b/frontend/src/styles/pages/_servers.less
new file mode 100644
index 00000000..425899d5
--- /dev/null
+++ b/frontend/src/styles/pages/_servers.less
@@ -0,0 +1,1183 @@
+// ============================================
+// SERVERS PAGE
+// ============================================
+
+// Page Layout
+.servers-page {
+ padding: 0;
+}
+
+// Stats Row
+.servers-stats {
+ display: grid;
+ grid-template-columns: repeat(4, 1fr);
+ gap: @space-4;
+ margin-bottom: @space-6;
+
+ @media (max-width: @breakpoint-lg) {
+ grid-template-columns: repeat(2, 1fr);
+ }
+
+ @media (max-width: @breakpoint-sm) {
+ grid-template-columns: 1fr;
+ }
+}
+
+.stat-card {
+ background: @bg-card;
+ border: 1px solid @border-subtle;
+ border-radius: @radius-md;
+ padding: @space-5;
+ display: flex;
+ align-items: center;
+ gap: @space-4;
+}
+
+.stat-icon {
+ width: 48px;
+ height: 48px;
+ border-radius: @radius-md;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+
+ svg {
+ width: 24px;
+ height: 24px;
+ }
+
+ &.total {
+ background: @accent-glow;
+ color: @accent-primary;
+ }
+
+ &.online {
+ background: @success-bg;
+ color: @success;
+ }
+
+ &.offline {
+ background: @danger-bg;
+ color: @danger;
+ }
+
+ &.connecting {
+ background: @warning-bg;
+ color: @warning;
+ }
+}
+
+.stat-content {
+ .stat-value {
+ font-family: @font-mono;
+ font-size: @font-size-2xl;
+ font-weight: @font-weight-bold;
+ color: @text-primary;
+ }
+
+ .stat-label {
+ font-size: @font-size-sm;
+ color: @text-tertiary;
+ }
+}
+
+// Toolbar
+.servers-toolbar {
+ display: flex;
+ gap: @space-4;
+ margin-bottom: @space-6;
+
+ @media (max-width: @breakpoint-sm) {
+ flex-direction: column;
+ }
+}
+
+.search-box {
+ position: relative;
+ flex: 1;
+
+ svg {
+ position: absolute;
+ left: @space-3;
+ top: 50%;
+ transform: translateY(-50%);
+ color: @text-tertiary;
+ }
+
+ input {
+ width: 100%;
+ background: @bg-card;
+ border: 1px solid @border-subtle;
+ border-radius: @radius-md;
+ padding: @space-3 @space-3 @space-3 @space-10;
+ color: @text-primary;
+ font-size: @font-size-sm;
+
+ &::placeholder {
+ color: @text-tertiary;
+ }
+
+ &:focus {
+ outline: none;
+ border-color: @accent-primary;
+ }
+ }
+}
+
+.group-filter {
+ select {
+ background: @bg-card;
+ border: 1px solid @border-subtle;
+ border-radius: @radius-md;
+ padding: @space-3 @space-4;
+ color: @text-primary;
+ font-size: @font-size-sm;
+ min-width: 160px;
+
+ &:focus {
+ outline: none;
+ border-color: @accent-primary;
+ }
+ }
+}
+
+// Servers Grid
+.servers-grid {
+ display: grid;
+ grid-template-columns: repeat(auto-fill, minmax(340px, 1fr));
+ gap: @space-5;
+}
+
+// Server Card
+.server-card {
+ background: @bg-card;
+ border: 1px solid @border-subtle;
+ border-radius: @radius-lg;
+ overflow: hidden;
+ transition: border-color @transition-base, box-shadow @transition-base;
+
+ &:hover {
+ border-color: @border-active;
+ }
+
+ &.online {
+ &:hover {
+ border-color: @success;
+ box-shadow: 0 0 0 1px @success-border;
+ }
+ }
+
+ &.offline {
+ opacity: 0.8;
+ }
+}
+
+.server-card-header {
+ display: flex;
+ align-items: center;
+ gap: @space-3;
+ padding: @space-4;
+ border-bottom: 1px solid @border-subtle;
+}
+
+.server-status-indicator {
+ width: 10px;
+ height: 10px;
+ border-radius: 50%;
+ flex-shrink: 0;
+}
+
+.server-info {
+ flex: 1;
+ min-width: 0;
+
+ .server-name {
+ font-size: @font-size-base;
+ font-weight: @font-weight-semibold;
+ color: @text-primary;
+ margin: 0;
+ white-space: nowrap;
+ overflow: hidden;
+ text-overflow: ellipsis;
+ }
+
+ .server-hostname {
+ font-size: @font-size-xs;
+ color: @text-tertiary;
+ font-family: @font-mono;
+ }
+}
+
+.server-actions-dropdown {
+ .btn-icon {
+ background: transparent;
+ border: none;
+ color: @text-tertiary;
+ cursor: pointer;
+ padding: @space-2;
+ border-radius: @radius-sm;
+
+ &:hover {
+ color: @text-primary;
+ background: @bg-hover;
+ }
+ }
+}
+
+.server-card-body {
+ padding: @space-4;
+}
+
+.server-meta {
+ display: grid;
+ grid-template-columns: repeat(2, 1fr);
+ gap: @space-3;
+ margin-bottom: @space-4;
+}
+
+.meta-item {
+ display: flex;
+ flex-direction: column;
+ gap: @space-1;
+
+ .meta-label {
+ font-size: @font-size-xs;
+ color: @text-tertiary;
+ text-transform: uppercase;
+ letter-spacing: 0.05em;
+ }
+
+ .meta-value {
+ font-size: @font-size-sm;
+ color: @text-secondary;
+ }
+}
+
+// Mini metrics bars
+.server-metrics-mini {
+ display: flex;
+ flex-direction: column;
+ gap: @space-2;
+ margin-bottom: @space-4;
+}
+
+.metric-bar {
+ display: flex;
+ align-items: center;
+ gap: @space-2;
+
+ .metric-label {
+ font-size: @font-size-xs;
+ color: @text-tertiary;
+ width: 32px;
+ }
+
+ .bar-track {
+ flex: 1;
+ height: 4px;
+ background: @bg-secondary;
+ border-radius: @radius-full;
+ overflow: hidden;
+ }
+
+ .bar-fill {
+ height: 100%;
+ border-radius: @radius-full;
+ transition: width @transition-base;
+
+ &.cpu {
+ background: @accent-primary;
+ }
+
+ &.memory {
+ background: @success;
+ }
+
+ &.disk {
+ background: @warning;
+ }
+ }
+
+ .metric-value {
+ font-size: @font-size-xs;
+ font-family: @font-mono;
+ color: @text-tertiary;
+ width: 32px;
+ text-align: right;
+ }
+}
+
+.server-group-badge {
+ display: inline-flex;
+ align-items: center;
+ gap: @space-1;
+ background: @bg-hover;
+ color: @text-secondary;
+ font-size: @font-size-xs;
+ padding: @space-1 @space-2;
+ border-radius: @radius-sm;
+}
+
+.server-card-footer {
+ display: flex;
+ gap: @space-2;
+ padding: @space-3 @space-4;
+ background: @bg-hover;
+ border-top: 1px solid @border-subtle;
+
+ .btn {
+ flex: 1;
+ justify-content: center;
+ }
+
+ .btn-sm {
+ padding: @space-2 @space-3;
+ font-size: @font-size-xs;
+ }
+}
+
+// Empty state
+.empty-state {
+ text-align: center;
+ padding: @space-16 @space-6;
+ background: @bg-card;
+ border: 1px solid @border-subtle;
+ border-radius: @radius-lg;
+
+ .empty-icon {
+ width: 64px;
+ height: 64px;
+ color: @text-tertiary;
+ margin-bottom: @space-4;
+ }
+
+ h3 {
+ font-size: @font-size-lg;
+ font-weight: @font-weight-semibold;
+ color: @text-primary;
+ margin: 0 0 @space-2;
+ }
+
+ p {
+ color: @text-secondary;
+ margin: 0 0 @space-6;
+ }
+}
+
+// ============================================
+// SERVER DETAIL PAGE
+// ============================================
+
+.server-detail-page {
+ padding: 0;
+}
+
+.page-breadcrumb {
+ display: flex;
+ align-items: center;
+ gap: @space-2;
+ font-size: @font-size-sm;
+ margin-bottom: @space-3;
+
+ a {
+ color: @text-tertiary;
+ text-decoration: none;
+
+ &:hover {
+ color: @text-primary;
+ }
+ }
+
+ .breadcrumb-separator {
+ color: @text-tertiary;
+ }
+
+ span:last-child {
+ color: @text-secondary;
+ }
+}
+
+.server-title {
+ display: flex;
+ align-items: center;
+ gap: @space-3;
+
+ h1 {
+ margin: 0;
+ }
+}
+
+.status-dot {
+ width: 12px;
+ height: 12px;
+ border-radius: 50%;
+
+ &.large {
+ width: 14px;
+ height: 14px;
+ }
+}
+
+.server-detail-tabs {
+ display: flex;
+ gap: @space-1;
+ margin-bottom: @space-6;
+ border-bottom: 1px solid @border-subtle;
+ padding-bottom: 0;
+}
+
+.tab-btn {
+ background: transparent;
+ border: none;
+ color: @text-tertiary;
+ font-size: @font-size-sm;
+ font-weight: @font-weight-medium;
+ padding: @space-3 @space-4;
+ cursor: pointer;
+ border-bottom: 2px solid transparent;
+ margin-bottom: -1px;
+ transition: all @transition-base;
+
+ &:hover {
+ color: @text-primary;
+ }
+
+ &.active {
+ color: @text-primary;
+ border-bottom-color: @accent-primary;
+ }
+}
+
+// Overview Tab
+.overview-grid {
+ display: grid;
+ grid-template-columns: repeat(2, 1fr);
+ gap: @space-5;
+
+ @media (max-width: @breakpoint-lg) {
+ grid-template-columns: 1fr;
+ }
+}
+
+.info-card {
+ background: @bg-card;
+ border: 1px solid @border-subtle;
+ border-radius: @radius-lg;
+ padding: @space-5;
+
+ h3 {
+ font-size: @font-size-sm;
+ font-weight: @font-weight-semibold;
+ color: @text-tertiary;
+ text-transform: uppercase;
+ letter-spacing: 0.05em;
+ margin: 0 0 @space-4;
+ }
+}
+
+.info-list {
+ display: flex;
+ flex-direction: column;
+ gap: @space-3;
+}
+
+.info-item {
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+
+ .info-label {
+ font-size: @font-size-sm;
+ color: @text-tertiary;
+ }
+
+ .info-value {
+ font-size: @font-size-sm;
+ color: @text-primary;
+
+ &.mono {
+ font-family: @font-mono;
+ font-size: @font-size-xs;
+ }
+ }
+}
+
+.status-badge {
+ display: inline-flex;
+ align-items: center;
+ gap: @space-1;
+ padding: @space-1 @space-2;
+ border-radius: @radius-sm;
+ font-size: @font-size-xs;
+ font-weight: @font-weight-medium;
+ text-transform: capitalize;
+
+ &.online {
+ background: @success-bg;
+ color: @success;
+ }
+
+ &.offline {
+ background: @danger-bg;
+ color: @danger;
+ }
+
+ &.connecting {
+ background: @warning-bg;
+ color: @warning;
+ }
+
+ &.pending {
+ background: @bg-secondary;
+ color: @text-tertiary;
+ }
+}
+
+// Resource Meters
+.metrics-card {
+ grid-column: span 2;
+
+ @media (max-width: @breakpoint-lg) {
+ grid-column: span 1;
+ }
+}
+
+.resource-meters {
+ display: grid;
+ grid-template-columns: repeat(3, 1fr);
+ gap: @space-6;
+
+ @media (max-width: @breakpoint-md) {
+ grid-template-columns: 1fr;
+ }
+}
+
+.resource-meter {
+ .resource-header {
+ display: flex;
+ justify-content: space-between;
+ margin-bottom: @space-2;
+
+ .resource-label {
+ font-size: @font-size-sm;
+ color: @text-secondary;
+ }
+
+ .resource-value {
+ font-family: @font-mono;
+ font-size: @font-size-sm;
+ color: @text-primary;
+ }
+ }
+
+ .resource-bar {
+ height: 8px;
+ background: @bg-secondary;
+ border-radius: @radius-full;
+ overflow: hidden;
+
+ .resource-fill {
+ height: 100%;
+ border-radius: @radius-full;
+ transition: width @transition-base;
+ }
+ }
+}
+
+.offline-card {
+ grid-column: span 2;
+
+ @media (max-width: @breakpoint-lg) {
+ grid-column: span 1;
+ }
+}
+
+.offline-message {
+ text-align: center;
+ padding: @space-6;
+
+ svg {
+ color: @text-tertiary;
+ margin-bottom: @space-4;
+ }
+
+ h4 {
+ font-size: @font-size-lg;
+ color: @text-primary;
+ margin: 0 0 @space-2;
+ }
+
+ p {
+ color: @text-secondary;
+ margin: 0;
+ }
+}
+
+.offline-notice {
+ text-align: center;
+ padding: @space-12;
+ background: @bg-card;
+ border: 1px solid @border-subtle;
+ border-radius: @radius-lg;
+
+ svg {
+ color: @text-tertiary;
+ margin-bottom: @space-4;
+ }
+
+ h4 {
+ font-size: @font-size-lg;
+ color: @text-primary;
+ margin: 0 0 @space-2;
+ }
+
+ p {
+ color: @text-secondary;
+ margin: 0;
+ }
+}
+
+// Docker Tab
+.docker-tab {
+ background: @bg-card;
+ border: 1px solid @border-subtle;
+ border-radius: @radius-lg;
+ overflow: hidden;
+}
+
+.docker-sub-tabs {
+ display: flex;
+ border-bottom: 1px solid @border-subtle;
+ padding: 0 @space-4;
+}
+
+.sub-tab {
+ background: transparent;
+ border: none;
+ color: @text-tertiary;
+ font-size: @font-size-sm;
+ padding: @space-4;
+ cursor: pointer;
+ border-bottom: 2px solid transparent;
+ margin-bottom: -1px;
+
+ &:hover {
+ color: @text-primary;
+ }
+
+ &.active {
+ color: @text-primary;
+ border-bottom-color: @accent-primary;
+ }
+}
+
+.containers-list,
+.images-list {
+ padding: @space-4;
+}
+
+.data-table {
+ width: 100%;
+ border-collapse: collapse;
+
+ th {
+ text-align: left;
+ font-size: @font-size-xs;
+ font-weight: @font-weight-semibold;
+ color: @text-tertiary;
+ text-transform: uppercase;
+ letter-spacing: 0.05em;
+ padding: @space-3;
+ border-bottom: 1px solid @border-subtle;
+ }
+
+ td {
+ padding: @space-3;
+ font-size: @font-size-sm;
+ color: @text-secondary;
+ border-bottom: 1px solid @border-subtle;
+ }
+
+ tr:last-child td {
+ border-bottom: none;
+ }
+
+ .container-name {
+ display: block;
+ color: @text-primary;
+ font-weight: @font-weight-medium;
+ }
+
+ .container-id {
+ display: block;
+ font-family: @font-mono;
+ font-size: @font-size-xs;
+ color: @text-tertiary;
+ }
+
+ .mono {
+ font-family: @font-mono;
+ font-size: @font-size-xs;
+ }
+}
+
+.status-pill {
+ display: inline-flex;
+ align-items: center;
+ gap: @space-1;
+ padding: @space-1 @space-2;
+ border-radius: @radius-sm;
+ font-size: @font-size-xs;
+ font-weight: @font-weight-medium;
+
+ &.running {
+ background: @success-bg;
+ color: @success;
+ }
+
+ &.stopped {
+ background: @bg-secondary;
+ color: @text-tertiary;
+ }
+}
+
+.actions-cell {
+ display: flex;
+ gap: @space-1;
+ justify-content: flex-end;
+}
+
+.btn-icon {
+ background: transparent;
+ border: none;
+ color: @text-tertiary;
+ cursor: pointer;
+ padding: @space-2;
+ border-radius: @radius-sm;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+
+ &:hover {
+ color: @text-primary;
+ background: @bg-hover;
+ }
+
+ &.success {
+ color: @success;
+
+ &:hover {
+ background: @success-bg;
+ }
+ }
+
+ &.danger {
+ color: @danger;
+
+ &:hover {
+ background: @danger-bg;
+ }
+ }
+}
+
+.empty-list {
+ text-align: center;
+ padding: @space-8;
+ color: @text-tertiary;
+}
+
+// Metrics Tab
+.metrics-tab {
+ padding: 0;
+}
+
+.metrics-grid {
+ display: grid;
+ grid-template-columns: repeat(3, 1fr);
+ gap: @space-5;
+
+ @media (max-width: @breakpoint-lg) {
+ grid-template-columns: repeat(2, 1fr);
+ }
+
+ @media (max-width: @breakpoint-md) {
+ grid-template-columns: 1fr;
+ }
+}
+
+.metric-card {
+ background: @bg-card;
+ border: 1px solid @border-subtle;
+ border-radius: @radius-lg;
+ padding: @space-5;
+
+ &.large {
+ display: flex;
+ flex-direction: column;
+ align-items: center;
+ }
+
+ h3 {
+ font-size: @font-size-sm;
+ font-weight: @font-weight-semibold;
+ color: @text-tertiary;
+ text-transform: uppercase;
+ letter-spacing: 0.05em;
+ margin: 0 0 @space-4;
+ text-align: center;
+ }
+}
+
+.metric-gauge {
+ display: flex;
+ justify-content: center;
+ margin-bottom: @space-4;
+}
+
+.circular-gauge {
+ width: 120px;
+ height: 120px;
+
+ .gauge-bg {
+ fill: none;
+ stroke: @bg-secondary;
+ stroke-width: 8;
+ }
+
+ .gauge-fill {
+ fill: none;
+ stroke-width: 8;
+ stroke-linecap: round;
+ transform: rotate(-90deg);
+ transform-origin: center;
+ }
+
+ .gauge-text {
+ font-family: @font-mono;
+ font-size: 20px;
+ font-weight: @font-weight-bold;
+ fill: @text-primary;
+ text-anchor: middle;
+ dominant-baseline: middle;
+ }
+}
+
+.metric-details {
+ width: 100%;
+}
+
+.detail-item {
+ display: flex;
+ justify-content: space-between;
+ padding: @space-2 0;
+ font-size: @font-size-sm;
+ border-top: 1px solid @border-subtle;
+
+ &:first-child {
+ border-top: none;
+ }
+
+ span:first-child {
+ color: @text-tertiary;
+ }
+
+ span:last-child {
+ color: @text-primary;
+ font-family: @font-mono;
+ }
+}
+
+.network-stats,
+.docker-stats {
+ display: flex;
+ flex-direction: column;
+ gap: @space-4;
+}
+
+.net-stat,
+.docker-stat {
+ display: flex;
+ align-items: center;
+ gap: @space-3;
+
+ svg {
+ color: @text-tertiary;
+ }
+
+ span:first-of-type {
+ color: @text-tertiary;
+ font-size: @font-size-sm;
+ flex: 1;
+ }
+
+ .value {
+ font-family: @font-mono;
+ font-size: @font-size-sm;
+ color: @text-primary;
+ }
+}
+
+// Settings Tab
+.settings-tab {
+ max-width: 600px;
+}
+
+.settings-form {
+ margin-bottom: @space-8;
+}
+
+.form-section {
+ background: @bg-card;
+ border: 1px solid @border-subtle;
+ border-radius: @radius-lg;
+ padding: @space-6;
+ margin-bottom: @space-6;
+
+ h3 {
+ font-size: @font-size-base;
+ font-weight: @font-weight-semibold;
+ color: @text-primary;
+ margin: 0 0 @space-4;
+ }
+
+ .section-description {
+ color: @text-secondary;
+ font-size: @font-size-sm;
+ margin-bottom: @space-4;
+ }
+
+ &.danger-zone {
+ border-color: @danger-border;
+
+ h3 {
+ color: @danger;
+ }
+ }
+}
+
+.form-row {
+ display: grid;
+ grid-template-columns: repeat(2, 1fr);
+ gap: @space-4;
+
+ @media (max-width: @breakpoint-sm) {
+ grid-template-columns: 1fr;
+ }
+}
+
+// ============================================
+// ADD SERVER MODAL
+// ============================================
+
+.permissions-grid {
+ display: grid;
+ grid-template-columns: repeat(2, 1fr);
+ gap: @space-2;
+
+ @media (max-width: @breakpoint-sm) {
+ grid-template-columns: 1fr;
+ }
+}
+
+.permission-checkbox {
+ display: flex;
+ align-items: center;
+ gap: @space-2;
+ font-size: @font-size-sm;
+ color: @text-secondary;
+ cursor: pointer;
+
+ input[type="checkbox"] {
+ width: 16px;
+ height: 16px;
+ accent-color: @accent-primary;
+ }
+
+ &:hover {
+ color: @text-primary;
+ }
+}
+
+.install-instructions {
+ padding: @space-4 0;
+}
+
+.success-banner {
+ display: flex;
+ align-items: center;
+ gap: @space-3;
+ background: @success-bg;
+ color: @success;
+ padding: @space-4;
+ border-radius: @radius-md;
+ margin-bottom: @space-6;
+
+ svg {
+ flex-shrink: 0;
+ }
+}
+
+.install-tabs {
+ display: flex;
+ flex-direction: column;
+ gap: @space-4;
+}
+
+.install-tab {
+ background: @bg-elevated;
+ border: 1px solid @border-subtle;
+ border-radius: @radius-md;
+ overflow: hidden;
+}
+
+.install-tab-header {
+ display: flex;
+ align-items: center;
+ gap: @space-3;
+ padding: @space-3 @space-4;
+ background: @bg-hover;
+ border-bottom: 1px solid @border-subtle;
+
+ svg {
+ color: @text-tertiary;
+ }
+
+ span {
+ flex: 1;
+ font-size: @font-size-sm;
+ font-weight: @font-weight-medium;
+ color: @text-primary;
+ }
+}
+
+.install-script {
+ padding: @space-4;
+ margin: 0;
+ font-family: @font-mono;
+ font-size: @font-size-xs;
+ color: @text-secondary;
+ background: @bg-body;
+ overflow-x: auto;
+ white-space: pre-wrap;
+ word-break: break-all;
+}
+
+.install-info {
+ margin-top: @space-6;
+ padding-top: @space-6;
+ border-top: 1px solid @border-subtle;
+
+ h4 {
+ font-size: @font-size-sm;
+ font-weight: @font-weight-semibold;
+ color: @text-primary;
+ margin: 0 0 @space-3;
+ }
+
+ ol {
+ margin: 0 0 @space-4;
+ padding-left: @space-5;
+ color: @text-secondary;
+ font-size: @font-size-sm;
+ }
+
+ li {
+ margin-bottom: @space-2;
+ }
+
+ .text-muted {
+ color: @text-tertiary;
+ font-size: @font-size-xs;
+ }
+}
+
+// ============================================
+// MANAGE GROUPS MODAL
+// ============================================
+
+.group-form {
+ display: flex;
+ gap: @space-3;
+ margin-bottom: @space-5;
+
+ input {
+ flex: 1;
+ background: @bg-elevated;
+ border: 1px solid @border-subtle;
+ border-radius: @radius-md;
+ padding: @space-3;
+ color: @text-primary;
+ font-size: @font-size-sm;
+
+ &::placeholder {
+ color: @text-tertiary;
+ }
+
+ &:focus {
+ outline: none;
+ border-color: @accent-primary;
+ }
+ }
+}
+
+.groups-list {
+ display: flex;
+ flex-direction: column;
+ gap: @space-2;
+ max-height: 300px;
+ overflow-y: auto;
+}
+
+.group-item {
+ display: flex;
+ align-items: center;
+ gap: @space-3;
+ padding: @space-3;
+ background: @bg-elevated;
+ border: 1px solid @border-subtle;
+ border-radius: @radius-md;
+
+ input {
+ flex: 1;
+ background: @bg-card;
+ border: 1px solid @accent-primary;
+ border-radius: @radius-sm;
+ padding: @space-2;
+ color: @text-primary;
+ font-size: @font-size-sm;
+
+ &:focus {
+ outline: none;
+ }
+ }
+
+ .group-name {
+ flex: 1;
+ display: flex;
+ align-items: center;
+ gap: @space-2;
+ font-size: @font-size-sm;
+ color: @text-primary;
+
+ svg {
+ color: @text-tertiary;
+ }
+ }
+
+ .group-count {
+ font-size: @font-size-xs;
+ color: @text-tertiary;
+ }
+
+ .group-actions {
+ display: flex;
+ gap: @space-1;
+ }
+}
+
+.empty-groups {
+ text-align: center;
+ padding: @space-6;
+ color: @text-tertiary;
+ font-size: @font-size-sm;
+}