ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.
Python astracloudflarecontrol-panelcyberpaneldnsfablehosting-control-panelhosting-panelkimi-k3server-managementserverkitubuntu-web-panelwebserver
Add agent fleet management, discovery & updates
Juan Denisd9dfc4d611b0
diff --git a/.gitignore b/.gitignoreindex ad077178..229390f8 100644--- a/.gitignore+++ b/.gitignore@@ -93,3 +93,4 @@ new_templates//logs//tmp/nul+SECURITY_AUDIT.mddiff --git a/agent/internal/agent/agent.go b/agent/internal/agent/agent.goindex 78b85ba0..152fd415 100644--- a/agent/internal/agent/agent.go+++ b/agent/internal/agent/agent.go@@ -6,7 +6,9 @@ import ("encoding/base64""encoding/json""fmt"+ "net""os"+ "runtime""sync""time"@@ -17,6 +19,7 @@ import ("github.com/serverkit/agent/internal/logger""github.com/serverkit/agent/internal/metrics""github.com/serverkit/agent/internal/terminal"+ "github.com/serverkit/agent/internal/updater""github.com/serverkit/agent/internal/ws""github.com/serverkit/agent/pkg/protocol")@@ -151,6 +154,13 @@ func (a *Agent) registerHandlers() {a.handlers[protocol.ActionSystemProcesses] = a.handleSystemProcesses}+ // File commands+ if a.cfg.Features.Files {+ a.handlers[protocol.ActionFileRead] = a.handleFileRead+ a.handlers[protocol.ActionFileWrite] = a.handleFileWrite+ a.handlers[protocol.ActionFileList] = a.handleFileList+ }+// Terminal commandsif a.terminal != nil {a.handlers[protocol.ActionTerminalCreate] = a.handleTerminalCreate@@ -158,6 +168,9 @@ func (a *Agent) registerHandlers() {a.handlers[protocol.ActionTerminalResize] = a.handleTerminalResizea.handlers[protocol.ActionTerminalClose] = a.handleTerminalClose}++ // Agent commands+ a.handlers[protocol.ActionAgentUpdate] = a.handleAgentUpdate}// Run starts the agent@@ -195,6 +208,9 @@ func (a *Agent) Run(ctx context.Context) error {// Start heartbeat loopgo a.heartbeatLoop(ctx)+ // Start discovery responder+ go a.discoveryLoop(ctx)+// Wait for context cancellation or restart requestselect {case <-ctx.Done():@@ -208,6 +224,85 @@ func (a *Agent) Run(ctx context.Context) error {return ctx.Err()}+// discoveryLoop listens for UDP discovery requests and responds with agent info+func (a *Agent) discoveryLoop(ctx context.Context) {+ // Simple UDP broadcast listener+ // Port 9000 matches DiscoveryService in backend+ port := 9000+ addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf(":%d", port))+ if err != nil {+ a.log.Error("Failed to resolve UDP address for discovery", "error", err)+ return+ }++ conn, err := net.ListenUDP("udp", addr)+ if err != nil {+ a.log.Error("Failed to listen for discovery broadcasts", "error", err)+ return+ }+ defer conn.Close()++ a.log.Info("Agent discovery responder started", "port", port)++ buf := make([]byte, 1024)+ for {+ select {+ case <-ctx.Done():+ return+ default:+ conn.SetReadDeadline(time.Now().Add(1 * time.Second))+ n, remoteAddr, err := conn.ReadFromUDP(buf)+ if err != nil {+ continue+ }++ var req struct {+ Type string `json:"type"`+ Timestamp int64 `json:"timestamp"`+ }+ if err := json.Unmarshal(buf[:n], &req); err != nil || (req.Type != "discovery_request" && req.Type != string(protocol.TypeDiscoveryRequest)) {+ continue+ }++ // Respond with agent info+ hostname, _ := os.Hostname()+ info := protocol.SystemInfo{+ Hostname: hostname,+ OS: runtime.GOOS,+ OSVersion: "", // Could populate this+ Architecture: runtime.GOARCH,+ AgentVersion: Version,+ }++ resp := struct {+ Type string `json:"type"`+ AgentID string `json:"agent_id"`+ Hostname string `json:"hostname"`+ AgentVersion string `json:"agent_version"`+ OS string `json:"os"`+ Arch string `json:"arch"`+ Timestamp int64 `json:"timestamp"`+ Info protocol.SystemInfo `json:"info"`+ }{+ Type: "discovery",+ AgentID: a.cfg.Agent.ID,+ Hostname: hostname,+ AgentVersion: Version,+ OS: runtime.GOOS,+ Arch: runtime.GOARCH,+ Timestamp: time.Now().UnixMilli(),+ Info: info,+ }++ data, _ := json.Marshal(resp)++ // Send response to remoteAddr on port+1+ respAddr, _ := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", remoteAddr.IP.String(), port+1))+ conn.WriteToUDP(data, respAddr)+ }+ }+}+// heartbeatLoop sends periodic heartbeatsfunc (a *Agent) heartbeatLoop(ctx context.Context) {ticker := time.NewTicker(a.cfg.Server.PingInterval)@@ -1094,3 +1189,51 @@ func (a *Agent) Restart() error {return fmt.Errorf("restart already in progress")}}++// handleAgentUpdate handles agent upgrade commands+func (a *Agent) handleAgentUpdate(ctx context.Context, params json.RawMessage) (interface{}, error) {+ var p struct {+ Version string `json:"version"`+ DownloadURL string `json:"download_url"`+ ChecksumsURL string `json:"checksums_url"`+ Force bool `json:"force"`+ }+ if err := json.Unmarshal(params, &p); err != nil {+ return nil, fmt.Errorf("invalid params: %w", err)+ }++ if p.Version == "" {+ return nil, fmt.Errorf("version is required")+ }++ a.log.Info("Agent update triggered via panel", "version", p.Version)++ // Create updater+ u := updater.New(a.cfg, a.log, Version)++ // Trigger update in background so we can respond to the command+ go func() {+ // Small delay to allow command result to be sent+ time.Sleep(2 * time.Second)++ // Download and install+ // In a real implementation, we would use the provided URLs+ // For now, we'll let the updater handle it using its default logic+ // or extend it to use the provided URLs.++ err := u.UpdateTo(context.Background(), p.Version, p.DownloadURL, p.ChecksumsURL)+ if err != nil {+ a.log.Error("Update failed", "error", err)+ return+ }++ a.log.Info("Update successful, restarting...")+ a.Restart()+ }()++ return map[string]interface{}{+ "success": true,+ "message": "Update triggered",+ "version": p.Version,+ }, nil+}diff --git a/agent/internal/updater/updater.go b/agent/internal/updater/updater.goindex 076e2c82..ab7cacd3 100644--- a/agent/internal/updater/updater.go+++ b/agent/internal/updater/updater.go@@ -63,6 +63,30 @@ func New(cfg *config.Config, log *logger.Logger, currentVersion string) *Updater}}+// UpdateTo performs an update to a specific version using provided URLs+func (u *Updater) UpdateTo(ctx context.Context, version, downloadURL, checksumsURL string) error {+ u.log.Info("Updating to specific version", "version", version)++ info := &VersionInfo{+ LatestVersion: version,+ DownloadURL: downloadURL,+ ChecksumsURL: checksumsURL,+ }++ // Download update+ newBinaryPath, err := u.DownloadUpdate(ctx, info)+ if err != nil {+ return fmt.Errorf("failed to download update: %w", err)+ }++ // Install update+ if err := u.InstallUpdate(newBinaryPath); err != nil {+ return fmt.Errorf("failed to install update: %w", err)+ }++ return nil+}+// CheckForUpdate checks if a new version is availablefunc (u *Updater) CheckForUpdate(ctx context.Context) (*VersionInfo, error) {u.log.Debug("Checking for updates", "current_version", u.currentVersion)diff --git a/agent/pkg/protocol/messages.go b/agent/pkg/protocol/messages.goindex 9d039dbb..db07f43f 100644--- a/agent/pkg/protocol/messages.go+++ b/agent/pkg/protocol/messages.go@@ -33,6 +33,10 @@ const (// SystemTypeSystemInfo MessageType = "system_info"+ // Discovery+ TypeDiscovery MessageType = "discovery"+ TypeDiscoveryRequest MessageType = "discovery_request"+// Credential RotationTypeCredentialUpdate MessageType = "credential_update"TypeCredentialUpdateAck MessageType = "credential_update_ack"@@ -209,6 +213,9 @@ const (ActionTerminalInput = "terminal:input"ActionTerminalResize = "terminal:resize"ActionTerminalClose = "terminal:close"++ // Agent actions+ ActionAgentUpdate = "agent:update")// Stream channelsdiff --git a/backend/app/api/servers.py b/backend/app/api/servers.pyindex 6fd31c5e..62bff3e2 100644--- a/backend/app/api/servers.py+++ b/backend/app/api/servers.py@@ -13,8 +13,10 @@ from flask_jwt_extended import jwt_required, get_jwt_identityfrom app import dbfrom app.models import User-from app.models.server import Server, ServerGroup, ServerMetrics, ServerCommand, AgentSession+from app.models.server import Server, ServerGroup, ServerMetrics, ServerCommand, AgentSession, AgentVersion, AgentRolloutfrom app.services.agent_registry import agent_registry+from app.services.agent_fleet_service import fleet_service+from app.services.discovery_service import discovery_servicefrom app.middleware.rbac import admin_required, developer_requiredservers_bp = Blueprint('servers', __name__)@@ -1848,3 +1850,203 @@ def trigger_agent_update(server_id):)return jsonify(result)+++# ==================== Agent Fleet Management ====================++@servers_bp.route('/fleet/health', methods=['GET'])+@jwt_required()+@admin_required+def get_fleet_health():+ """Get aggregated health metrics for the agent fleet"""+ return jsonify(fleet_service.get_fleet_health())+++@servers_bp.route('/fleet/versions', methods=['GET'])+@jwt_required()+@admin_required+def list_agent_versions():+ """List all available agent versions"""+ versions = AgentVersion.query.order_by(AgentVersion.version.desc()).all()+ return jsonify([v.to_dict() for v in versions])+++@servers_bp.route('/fleet/versions', methods=['POST'])+@jwt_required()+@admin_required+def add_agent_version():+ """Add a new available agent version"""+ data = request.get_json()++ if not data.get('version'):+ return jsonify({'error': 'Version is required'}), 400++ version = AgentVersion(+ version=data['version'],+ channel=data.get('channel', 'stable'),+ min_panel_version=data.get('min_panel_version'),+ max_panel_version=data.get('max_panel_version'),+ release_notes=data.get('release_notes'),+ assets=data.get('assets', {}),+ published_at=datetime.fromisoformat(data['published_at']) if data.get('published_at') else datetime.utcnow()+ )++ db.session.add(version)+ db.session.commit()++ return jsonify(version.to_dict()), 201+++@servers_bp.route('/fleet/upgrade', methods=['POST'])+@jwt_required()+@admin_required+def upgrade_fleet():+ """Trigger upgrade for selected servers or entire fleet"""+ data = request.get_json()+ server_ids = data.get('server_ids', [])+ version_id = data.get('version_id')+ user_id = get_jwt_identity()++ if not server_ids:+ # If no IDs provided, upgrade all online servers+ servers = Server.query.filter_by(status='online').all()+ server_ids = [s.id for s in servers]++ if not server_ids:+ return jsonify({'success': True, 'message': 'No online servers to upgrade'})++ result = fleet_service.upgrade_servers(server_ids, version_id, user_id)+ return jsonify(result)+++@servers_bp.route('/fleet/rollout', methods=['POST'])+@jwt_required()+@admin_required+def start_staged_rollout():+ """Start a staged rollout"""+ data = request.get_json()+ group_id = data.get('group_id')+ version_id = data.get('version_id')+ batch_size = data.get('batch_size', 5)+ delay_minutes = data.get('delay_minutes', 10)+ strategy = data.get('strategy', 'staged')+ server_ids = data.get('server_ids')+ user_id = get_jwt_identity()++ if not version_id:+ return jsonify({'error': 'version_id is required'}), 400++ result = fleet_service.staged_rollout(+ group_id, version_id, batch_size, delay_minutes,+ strategy, user_id, server_ids+ )+ return jsonify(result)+++@servers_bp.route('/fleet/rollouts', methods=['GET'])+@jwt_required()+@admin_required+def list_rollouts():+ """List rollout history"""+ status = request.args.get('status')+ limit = request.args.get('limit', 20, type=int)+ return jsonify(fleet_service.get_rollouts(status, limit))+++@servers_bp.route('/fleet/rollouts/<rollout_id>', methods=['GET'])+@jwt_required()+@admin_required+def get_rollout(rollout_id):+ """Get a specific rollout"""+ rollout = fleet_service.get_rollout(rollout_id)+ if not rollout:+ return jsonify({'error': 'Rollout not found'}), 404+ return jsonify(rollout)+++@servers_bp.route('/fleet/rollouts/<rollout_id>/cancel', methods=['POST'])+@jwt_required()+@admin_required+def cancel_rollout(rollout_id):+ """Cancel an active rollout"""+ success = fleet_service.cancel_rollout(rollout_id)+ if not success:+ return jsonify({'error': 'Cannot cancel rollout (not running or not found)'}), 400+ return jsonify({'success': True, 'message': 'Rollout cancelled'})+++@servers_bp.route('/fleet/discovery', methods=['POST'])+@jwt_required()+@admin_required+def start_discovery_scan():+ """Start a network scan for new agents"""+ duration = request.args.get('duration', 10, type=int)+ agents = discovery_service.start_scan(duration)+ return jsonify(agents)+++@servers_bp.route('/fleet/discovery', methods=['GET'])+@jwt_required()+@admin_required+def get_discovered_agents():+ """Get results of last discovery scan"""+ return jsonify(discovery_service.get_discovered_agents())+++@servers_bp.route('/fleet/approve/<server_id>', methods=['POST'])+@jwt_required()+@admin_required+def approve_agent_registration(server_id):+ """Approve a pending agent registration"""+ user_id = get_jwt_identity()+ success = fleet_service.approve_registration(server_id, user_id)++ if not success:+ return jsonify({'error': 'Failed to approve registration'}), 400++ return jsonify({'success': True, 'message': 'Registration approved'})+++@servers_bp.route('/fleet/reject/<server_id>', methods=['POST'])+@jwt_required()+@admin_required+def reject_agent_registration(server_id):+ """Reject a pending agent registration"""+ success = fleet_service.reject_registration(server_id)++ if not success:+ return jsonify({'error': 'Failed to reject registration'}), 400++ return jsonify({'success': True, 'message': 'Registration rejected'})+++@servers_bp.route('/fleet/commands/queued', methods=['GET'])+@jwt_required()+@admin_required+def get_queued_commands():+ """Get all pending queued commands"""+ server_id = request.args.get('server_id')+ commands = fleet_service.get_queued_commands(server_id)+ return jsonify(commands)+++@servers_bp.route('/fleet/commands/<command_id>/retry', methods=['POST'])+@jwt_required()+@admin_required+def retry_command(command_id):+ """Retry a failed command"""+ result = fleet_service.retry_command(command_id)+ if not result.get('success'):+ return jsonify(result), 400+ return jsonify(result)+++@servers_bp.route('/fleet/diagnostics/<server_id>', methods=['GET'])+@jwt_required()+@admin_required+def get_server_diagnostics(server_id):+ """Get detailed connection diagnostics for a server"""+ diagnostics = fleet_service.get_server_diagnostics(server_id)+ if 'error' in diagnostics:+ return jsonify(diagnostics), 404+ return jsonify(diagnostics)diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.pyindex 508fe598..6d608ed5 100644--- a/backend/app/models/__init__.py+++ b/backend/app/models/__init__.py@@ -9,7 +9,7 @@ from app.models.audit_log import AuditLogfrom app.models.metrics_history import MetricsHistoryfrom app.models.workflow import Workflow, WorkflowExecution, WorkflowLogfrom app.models.webhook import GitWebhook, WebhookLog, GitDeployment-from app.models.server import Server, ServerGroup, ServerMetrics, ServerCommand, AgentSession+from app.models.server import Server, ServerGroup, ServerMetrics, ServerCommand, AgentSession, AgentVersion, AgentRolloutfrom app.models.security_alert import SecurityAlertfrom app.models.wordpress_site import WordPressSite, DatabaseSnapshot, SyncJobfrom app.models.environment_activity import EnvironmentActivity@@ -26,7 +26,7 @@ __all__ = ['User', 'Application', 'Domain', 'EnvironmentVariable', 'EnvironmentVariableHistory','NotificationPreferences', 'Deployment', 'DeploymentDiff', 'SystemSettings', 'AuditLog','MetricsHistory', 'Workflow', 'WorkflowExecution', 'WorkflowLog', 'GitWebhook', 'WebhookLog', 'GitDeployment',- 'Server', 'ServerGroup', 'ServerMetrics', 'ServerCommand', 'AgentSession', 'SecurityAlert',+ 'Server', 'ServerGroup', 'ServerMetrics', 'ServerCommand', 'AgentSession', 'AgentVersion', 'AgentRollout', 'SecurityAlert','WordPressSite', 'DatabaseSnapshot', 'SyncJob','EnvironmentActivity', 'PromotionJob', 'SanitizationProfile','EmailDomain', 'EmailAccount', 'EmailAlias', 'EmailForwardingRule', 'DNSProviderConfig',diff --git a/backend/app/models/server.py b/backend/app/models/server.pyindex 4004a8fc..c92cf70d 100644--- a/backend/app/models/server.py+++ b/backend/app/models/server.py@@ -16,6 +16,10 @@ class ServerGroup(db.Model):icon = db.Column(db.String(50), default='server') # Icon nameparent_id = db.Column(db.String(36), db.ForeignKey('server_groups.id'), nullable=True)+ # Fleet Management+ auto_upgrade = db.Column(db.Boolean, default=False)+ upgrade_channel = db.Column(db.String(20), default='stable') # stable, beta+created_at = db.Column(db.DateTime, default=datetime.utcnow)updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)@@ -31,6 +35,8 @@ class ServerGroup(db.Model):'color': self.color,'icon': self.icon,'parent_id': self.parent_id,+ 'auto_upgrade': self.auto_upgrade,+ 'upgrade_channel': self.upgrade_channel,'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,@@ -68,6 +74,8 @@ class Server(db.Model):# Agent Infoagent_version = db.Column(db.String(20))agent_id = db.Column(db.String(36), unique=True, index=True) # Agent's UUID+ auto_upgrade = db.Column(db.Boolean, default=False)+ upgrade_channel = db.Column(db.String(20), default='stable') # stable, beta# System Info (reported by agent)os_type = db.Column(db.String(20)) # linux, windows, darwin@@ -378,6 +386,13 @@ class ServerCommand(db.Model):error = db.Column(db.Text)exit_code = db.Column(db.Integer)+ # Retry / offline queue+ retry_count = db.Column(db.Integer, default=0)+ max_retries = db.Column(db.Integer, default=3)+ next_retry_at = db.Column(db.DateTime)+ backoff_seconds = db.Column(db.Integer, default=30) # initial backoff, doubles each retry+ queued = db.Column(db.Boolean, default=False) # True when agent was offline at send time+created_at = db.Column(db.DateTime, default=datetime.utcnow)server = db.relationship('Server', back_populates='commands')@@ -395,6 +410,9 @@ class ServerCommand(db.Model):'result': self.result,'error': self.error,'exit_code': self.exit_code,+ 'retry_count': self.retry_count,+ 'max_retries': self.max_retries,+ 'queued': self.queued,'created_at': self.created_at.isoformat() if self.created_at else None,}@@ -414,12 +432,29 @@ class AgentSession(db.Model):ip_address = db.Column(db.String(45))user_agent = db.Column(db.String(255)) # Agent version info+ # Latency tracking+ heartbeat_latency_ms = db.Column(db.Float) # Latest heartbeat round-trip latency+ avg_latency_ms = db.Column(db.Float) # Running average latency+ latency_samples = db.Column(db.Integer, default=0) # Number of samples in average+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 update_latency(self, latency_ms):+ """Update latency with exponential moving average"""+ self.heartbeat_latency_ms = latency_ms+ if self.avg_latency_ms is None or self.latency_samples == 0:+ self.avg_latency_ms = latency_ms+ self.latency_samples = 1+ else:+ # EMA with alpha = 0.2 for smoothing+ alpha = 0.2+ self.avg_latency_ms = alpha * latency_ms + (1 - alpha) * self.avg_latency_ms+ self.latency_samples += 1+def to_dict(self):return {'id': self.id,@@ -427,7 +462,107 @@ class AgentSession(db.Model):'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,+ 'heartbeat_latency_ms': self.heartbeat_latency_ms,+ 'avg_latency_ms': self.avg_latency_ms,'is_active': self.is_active,'disconnected_at': self.disconnected_at.isoformat() if self.disconnected_at else None,'disconnect_reason': self.disconnect_reason,}+++class AgentRollout(db.Model):+ """Tracks staged rollout progress"""+ __tablename__ = 'agent_rollouts'++ id = db.Column(db.String(36), primary_key=True, default=lambda: str(uuid.uuid4()))+ version_id = db.Column(db.String(36), db.ForeignKey('agent_versions.id'), nullable=False)+ group_id = db.Column(db.String(36), db.ForeignKey('server_groups.id'), nullable=True)+ user_id = db.Column(db.Integer, db.ForeignKey('users.id'))++ # Configuration+ batch_size = db.Column(db.Integer, default=5)+ delay_minutes = db.Column(db.Integer, default=10)+ strategy = db.Column(db.String(20), default='staged') # staged, all, canary++ # Progress+ status = db.Column(db.String(20), default='pending') # pending, running, paused, completed, failed, cancelled+ total_servers = db.Column(db.Integer, default=0)+ processed_servers = db.Column(db.Integer, default=0)+ failed_servers = db.Column(db.Integer, default=0)+ current_wave = db.Column(db.Integer, default=0)++ # Results per server+ server_results = db.Column(db.JSON, default=list) # [{server_id, status, error, wave}]++ error = db.Column(db.Text)++ started_at = db.Column(db.DateTime)+ completed_at = db.Column(db.DateTime)+ created_at = db.Column(db.DateTime, default=datetime.utcnow)+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)++ version = db.relationship('AgentVersion')++ def to_dict(self):+ return {+ 'id': self.id,+ 'version_id': self.version_id,+ 'version': self.version.version if self.version else None,+ 'group_id': self.group_id,+ 'user_id': self.user_id,+ 'batch_size': self.batch_size,+ 'delay_minutes': self.delay_minutes,+ 'strategy': self.strategy,+ 'status': self.status,+ 'total_servers': self.total_servers,+ 'processed_servers': self.processed_servers,+ 'failed_servers': self.failed_servers,+ 'current_wave': self.current_wave,+ 'server_results': self.server_results or [],+ 'error': self.error,+ 'started_at': self.started_at.isoformat() if self.started_at else None,+ 'completed_at': self.completed_at.isoformat() if self.completed_at else None,+ 'created_at': self.created_at.isoformat() if self.created_at else None,+ }+++class AgentVersion(db.Model):+ """Available agent versions and compatibility matrix"""+ __tablename__ = 'agent_versions'++ id = db.Column(db.String(36), primary_key=True, default=lambda: str(uuid.uuid4()))+ version = db.Column(db.String(20), nullable=False, unique=True)+ channel = db.Column(db.String(20), default='stable') # stable, beta++ # Compatibility+ min_panel_version = db.Column(db.String(20))+ max_panel_version = db.Column(db.String(20))++ # Metadata+ release_notes = db.Column(db.Text)+ is_active = db.Column(db.Boolean, default=True)+ published_at = db.Column(db.DateTime, default=datetime.utcnow)++ # Assets (mapped by platform: linux-amd64, windows-amd64, etc.)+ assets = db.Column(db.JSON) # {"linux-amd64": "url", "checksums": "url"}++ created_at = db.Column(db.DateTime, default=datetime.utcnow)+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)++ def to_dict(self):+ return {+ 'id': self.id,+ 'version': self.version,+ 'channel': self.channel,+ 'min_panel_version': self.min_panel_version,+ 'max_panel_version': self.max_panel_version,+ 'release_notes': self.release_notes,+ 'is_active': self.is_active,+ 'published_at': self.published_at.isoformat() if self.published_at else None,+ 'assets': self.assets or {},+ 'created_at': self.created_at.isoformat() if self.created_at else None,+ 'updated_at': self.updated_at.isoformat() if self.updated_at else None,+ }++ def __repr__(self):+ return f'<AgentVersion {self.version}>'diff --git a/backend/app/services/agent_fleet_service.py b/backend/app/services/agent_fleet_service.pynew file mode 100644index 00000000..a6b19656--- /dev/null+++ b/backend/app/services/agent_fleet_service.py@@ -0,0 +1,542 @@+"""+AgentFleet Service++Manages agent fleet operations including bulk upgrades, staged rollouts,+health monitoring, offline command queuing, and retry with backoff.+"""++from datetime import datetime, timedelta+from typing import List, Dict, Optional+import threading+import time+import uuid++from app import db+from app.models.server import (+ Server, ServerGroup, AgentVersion, ServerCommand, AgentSession, AgentRollout+)+from app.services.agent_registry import agent_registry+++class AgentFleetService:+ """Service for managing a fleet of agents."""++ def __init__(self):+ self._rollout_threads = {}+ self._rollout_cancel = {} # rollout_id -> threading.Event++ # ==================== Fleet Health ====================++ def get_fleet_health(self) -> Dict:+ """Get aggregated health metrics for the entire fleet."""+ now = datetime.utcnow()+ one_hour_ago = now - timedelta(hours=1)++ servers = Server.query.all()+ total_count = len(servers)++ online_count = sum(1 for s in servers if s.status == 'online')+ offline_count = sum(1 for s in servers if s.status == 'offline')+ pending_count = sum(1 for s in servers if s.status == 'pending')++ # Real heartbeat latency from active sessions+ active_sessions = AgentSession.query.filter_by(is_active=True).all()+ latencies = [s.avg_latency_ms for s in active_sessions if s.avg_latency_ms is not None]+ avg_latency = sum(latencies) / len(latencies) if latencies else 0.0++ # Command success rate in the last hour+ commands = ServerCommand.query.filter(ServerCommand.created_at >= one_hour_ago).all()+ if commands:+ success_count = sum(1 for c in commands if c.status == 'completed')+ command_success_rate = (success_count / len(commands)) * 100+ else:+ command_success_rate = 100.0++ # Queued commands count+ queued_count = ServerCommand.query.filter_by(queued=True, status='pending').count()++ return {+ 'total_servers': total_count,+ 'online_servers': online_count,+ 'offline_servers': offline_count,+ 'pending_servers': pending_count,+ 'uptime_percentage': (online_count / total_count * 100) if total_count > 0 else 100,+ 'avg_heartbeat_latency': round(avg_latency, 1),+ 'command_success_rate': round(command_success_rate, 1),+ 'queued_commands': queued_count,+ 'version_distribution': self._get_version_distribution(servers)+ }++ def _get_version_distribution(self, servers: List[Server]) -> Dict[str, int]:+ """Calculate distribution of agent versions."""+ dist = {}+ for s in servers:+ version = s.agent_version or 'unknown'+ dist[version] = dist.get(version, 0) + 1+ return dist++ # ==================== Upgrades ====================++ def upgrade_servers(self, server_ids: List[str], version_id: Optional[str] = None, user_id: int = None) -> Dict:+ """Trigger upgrades for a list of servers."""+ version = None+ if version_id:+ version = AgentVersion.query.get(version_id)+ else:+ version = AgentVersion.query.filter_by(+ channel='stable', is_active=True+ ).order_by(AgentVersion.version.desc()).first()++ if not version:+ return {'success': False, 'error': 'No suitable agent version found'}++ results = []+ for server_id in server_ids:+ server = Server.query.get(server_id)+ if not server:+ results.append({'server_id': server_id, 'success': False, 'error': 'Server not found'})+ continue++ platform = f"{server.os_type}-{server.architecture}"+ download_url = version.assets.get(platform) if version.assets else None++ if not download_url:+ results.append({'server_id': server_id, 'success': False, 'error': f'No asset for platform {platform}'})+ continue++ params = {+ 'version': version.version,+ 'download_url': download_url,+ 'checksums_url': version.assets.get('checksums') if version.assets else None+ }++ if server.status != 'online':+ # Queue command for offline agent+ self.queue_command(server_id, 'agent:update', params, user_id=user_id)+ results.append({'server_id': server_id, 'success': True, 'message': 'Upgrade queued (agent offline)'})+ continue++ threading.Thread(+ target=agent_registry.send_command,+ args=(server_id, 'agent:update', params),+ kwargs={'user_id': user_id, 'timeout': 60.0},+ daemon=True+ ).start()++ results.append({'server_id': server_id, 'success': True, 'message': 'Upgrade triggered'})++ return {'success': True, 'results': results}++ # ==================== Staged Rollouts ====================++ def staged_rollout(+ self, group_id: str, version_id: str,+ batch_size: int = 5, delay_minutes: int = 10,+ strategy: str = 'staged', user_id: int = None,+ server_ids: List[str] = None+ ) -> Dict:+ """Perform a staged rollout of an agent version."""+ version = AgentVersion.query.get(version_id)+ if not version:+ return {'success': False, 'error': 'Version not found'}++ if group_id:+ group = ServerGroup.query.get(group_id)+ if not group:+ return {'success': False, 'error': 'Group not found'}+ target_servers = Server.query.filter_by(group_id=group_id, status='online').all()+ elif server_ids:+ target_servers = Server.query.filter(+ Server.id.in_(server_ids), Server.status == 'online'+ ).all()+ else:+ target_servers = Server.query.filter_by(status='online').all()++ if not target_servers:+ return {'success': True, 'message': 'No online servers to upgrade'}++ ids = [s.id for s in target_servers]++ # Create persistent rollout record+ rollout = AgentRollout(+ version_id=version_id,+ group_id=group_id,+ user_id=user_id,+ batch_size=batch_size,+ delay_minutes=delay_minutes,+ strategy=strategy,+ status='running',+ total_servers=len(ids),+ started_at=datetime.utcnow()+ )+ db.session.add(rollout)+ db.session.commit()++ rollout_id = rollout.id++ # Setup cancellation+ cancel_event = threading.Event()+ self._rollout_cancel[rollout_id] = cancel_event++ thread = threading.Thread(+ target=self._run_staged_rollout,+ args=(rollout_id, ids, version_id, batch_size, delay_minutes, user_id, cancel_event),+ daemon=True+ )+ self._rollout_threads[rollout_id] = thread+ thread.start()++ return {'success': True, 'rollout_id': rollout_id, 'rollout': rollout.to_dict()}++ def _run_staged_rollout(self, rollout_id, server_ids, version_id, batch_size, delay_minutes, user_id, cancel_event):+ """Run staged rollout in batches with health checks between waves."""+ from app import create_app+ app = create_app()++ with app.app_context():+ total = len(server_ids)+ processed = 0+ failed = 0+ wave = 0+ server_results = []++ for i in range(0, total, batch_size):+ if cancel_event.is_set():+ self._update_rollout_status(rollout_id, 'cancelled', processed, failed, wave, server_results)+ return++ batch = server_ids[i:i + batch_size]+ wave += 1++ # Upgrade this batch+ result = self.upgrade_servers(batch, version_id, user_id)+ batch_results = result.get('results', [])++ for r in batch_results:+ server_results.append({+ 'server_id': r['server_id'],+ 'status': 'success' if r.get('success') else 'failed',+ 'error': r.get('error'),+ 'wave': wave+ })+ if not r.get('success'):+ failed += 1++ processed += len(batch)++ # Update rollout progress+ self._update_rollout_status(rollout_id, 'running', processed, failed, wave, server_results)++ if processed < total:+ # Health check: if more than 50% of current wave failed, abort+ wave_failures = sum(1 for r in batch_results if not r.get('success'))+ if wave_failures > len(batch) * 0.5:+ self._update_rollout_status(+ rollout_id, 'failed', processed, failed, wave, server_results,+ error=f'Wave {wave} had >50% failures ({wave_failures}/{len(batch)}), aborting rollout'+ )+ return++ # Wait between waves, checking for cancellation+ wait_seconds = delay_minutes * 60+ if cancel_event.wait(timeout=wait_seconds):+ self._update_rollout_status(rollout_id, 'cancelled', processed, failed, wave, server_results)+ return++ # Post-wave health check: verify previous batch servers are still online+ offline_count = 0+ for sid in batch:+ server = Server.query.get(sid)+ if server and server.status != 'online':+ offline_count += 1++ if offline_count > len(batch) * 0.3:+ self._update_rollout_status(+ rollout_id, 'failed', processed, failed, wave, server_results,+ error=f'Post-wave health check failed: {offline_count}/{len(batch)} servers offline after wave {wave}'+ )+ return++ self._update_rollout_status(rollout_id, 'completed', processed, failed, wave, server_results)++ def _update_rollout_status(self, rollout_id, status, processed, failed, wave, server_results, error=None):+ """Update rollout record in database."""+ try:+ rollout = AgentRollout.query.get(rollout_id)+ if rollout:+ rollout.status = status+ rollout.processed_servers = processed+ rollout.failed_servers = failed+ rollout.current_wave = wave+ rollout.server_results = server_results+ rollout.error = error+ if status in ('completed', 'failed', 'cancelled'):+ rollout.completed_at = datetime.utcnow()+ db.session.commit()+ except Exception as e:+ print(f"Error updating rollout status: {e}")+ db.session.rollback()++ def cancel_rollout(self, rollout_id: str) -> bool:+ """Cancel an active rollout."""+ cancel_event = self._rollout_cancel.get(rollout_id)+ if cancel_event:+ cancel_event.set()+ return True++ # Try to cancel in DB directly if thread already finished+ rollout = AgentRollout.query.get(rollout_id)+ if rollout and rollout.status == 'running':+ rollout.status = 'cancelled'+ rollout.completed_at = datetime.utcnow()+ db.session.commit()+ return True++ return False++ def get_rollouts(self, status: str = None, limit: int = 20) -> List[Dict]:+ """Get rollout history."""+ query = AgentRollout.query.order_by(AgentRollout.created_at.desc())+ if status:+ query = query.filter_by(status=status)+ rollouts = query.limit(limit).all()+ return [r.to_dict() for r in rollouts]++ def get_rollout(self, rollout_id: str) -> Optional[Dict]:+ """Get a specific rollout."""+ rollout = AgentRollout.query.get(rollout_id)+ return rollout.to_dict() if rollout else None++ # ==================== Registration ====================++ def approve_registration(self, server_id: str, user_id: int) -> bool:+ """Approve a pending agent registration."""+ server = Server.query.get(server_id)+ if not server or server.status != 'pending':+ return False++ server.status = 'connecting'+ server.registered_by = user_id+ server.registered_at = datetime.utcnow()+ db.session.commit()+ return True++ def reject_registration(self, server_id: str) -> bool:+ """Reject and delete a pending agent registration."""+ server = Server.query.get(server_id)+ if not server or server.status != 'pending':+ return False++ db.session.delete(server)+ db.session.commit()+ return True++ # ==================== Offline Command Queue ====================++ def queue_command(+ self, server_id: str, action: str, params: dict = None,+ user_id: int = None, max_retries: int = 3, backoff_seconds: int = 30+ ) -> ServerCommand:+ """Queue a command for an offline agent. Delivered on reconnect."""+ command = ServerCommand(+ id=str(uuid.uuid4()),+ server_id=server_id,+ user_id=user_id,+ command_type=action,+ command_data=params,+ status='pending',+ queued=True,+ max_retries=max_retries,+ backoff_seconds=backoff_seconds+ )+ db.session.add(command)+ db.session.commit()+ return command++ def deliver_queued_commands(self, server_id: str):+ """Deliver all queued commands for a server that just reconnected."""+ commands = ServerCommand.query.filter_by(+ server_id=server_id, queued=True, status='pending'+ ).order_by(ServerCommand.created_at.asc()).all()++ for cmd in commands:+ cmd.queued = False+ cmd.status = 'running'+ cmd.started_at = datetime.utcnow()+ db.session.commit()++ # Send asynchronously+ threading.Thread(+ target=self._deliver_single_command,+ args=(server_id, cmd.id, cmd.command_type, cmd.command_data, cmd.user_id),+ daemon=True+ ).start()++ def _deliver_single_command(self, server_id, command_id, action, params, user_id):+ """Send a single queued command and update its status."""+ from app import create_app+ app = create_app()++ with app.app_context():+ result = agent_registry.send_command(+ server_id, action, params, user_id=user_id, timeout=60.0+ )++ try:+ cmd = ServerCommand.query.get(command_id)+ if cmd:+ if result.get('success'):+ cmd.status = 'completed'+ cmd.result = result.get('data')+ else:+ cmd.status = 'failed'+ cmd.error = result.get('error')+ cmd.completed_at = datetime.utcnow()+ db.session.commit()+ except Exception as e:+ print(f"Error updating queued command: {e}")+ db.session.rollback()++ def get_queued_commands(self, server_id: str = None) -> List[Dict]:+ """Get all pending queued commands, optionally filtered by server."""+ query = ServerCommand.query.filter_by(queued=True, status='pending')+ if server_id:+ query = query.filter_by(server_id=server_id)+ return [c.to_dict() for c in query.order_by(ServerCommand.created_at.asc()).all()]++ # ==================== Command Retry ====================++ def retry_command(self, command_id: str) -> Dict:+ """Retry a failed command with exponential backoff."""+ cmd = ServerCommand.query.get(command_id)+ if not cmd:+ return {'success': False, 'error': 'Command not found'}++ if cmd.status not in ('failed', 'timeout'):+ return {'success': False, 'error': f'Cannot retry command with status: {cmd.status}'}++ if cmd.retry_count >= cmd.max_retries:+ return {'success': False, 'error': f'Max retries ({cmd.max_retries}) exceeded'}++ server = Server.query.get(cmd.server_id)+ if not server:+ return {'success': False, 'error': 'Server not found'}++ cmd.retry_count += 1++ if server.status != 'online':+ # Re-queue for offline delivery+ cmd.queued = True+ cmd.status = 'pending'+ # Exponential backoff for next_retry_at+ backoff = cmd.backoff_seconds * (2 ** (cmd.retry_count - 1))+ cmd.next_retry_at = datetime.utcnow() + timedelta(seconds=backoff)+ db.session.commit()+ return {'success': True, 'message': 'Command re-queued (agent offline)', 'retry_count': cmd.retry_count}++ # Agent is online, send immediately+ cmd.status = 'running'+ cmd.started_at = datetime.utcnow()+ db.session.commit()++ threading.Thread(+ target=self._deliver_single_command,+ args=(cmd.server_id, cmd.id, cmd.command_type, cmd.command_data, cmd.user_id),+ daemon=True+ ).start()++ return {'success': True, 'message': 'Command retry triggered', 'retry_count': cmd.retry_count}++ def process_scheduled_retries(self):+ """Process commands that are due for retry. Call periodically."""+ now = datetime.utcnow()+ commands = ServerCommand.query.filter(+ ServerCommand.status == 'pending',+ ServerCommand.queued == True,+ ServerCommand.next_retry_at != None,+ ServerCommand.next_retry_at <= now+ ).all()++ for cmd in commands:+ server = Server.query.get(cmd.server_id)+ if server and server.status == 'online':+ cmd.queued = False+ cmd.status = 'running'+ cmd.started_at = datetime.utcnow()+ db.session.commit()++ threading.Thread(+ target=self._deliver_single_command,+ args=(cmd.server_id, cmd.id, cmd.command_type, cmd.command_data, cmd.user_id),+ daemon=True+ ).start()++ # ==================== Diagnostics ====================++ def get_server_diagnostics(self, server_id: str) -> Dict:+ """Get detailed connection diagnostics for a server."""+ server = Server.query.get(server_id)+ if not server:+ return {'error': 'Server not found'}++ # Active session+ active_session = AgentSession.query.filter_by(+ server_id=server_id, is_active=True+ ).first()++ # Recent sessions (last 10)+ recent_sessions = AgentSession.query.filter_by(+ server_id=server_id+ ).order_by(AgentSession.connected_at.desc()).limit(10).all()++ # Command stats (last 24h)+ one_day_ago = datetime.utcnow() - timedelta(hours=24)+ recent_commands = ServerCommand.query.filter(+ ServerCommand.server_id == server_id,+ ServerCommand.created_at >= one_day_ago+ ).all()++ total_cmds = len(recent_commands)+ success_cmds = sum(1 for c in recent_commands if c.status == 'completed')+ failed_cmds = sum(1 for c in recent_commands if c.status == 'failed')+ timeout_cmds = sum(1 for c in recent_commands if c.status == 'timeout')++ # Calculate uptime from sessions+ uptime_seconds = 0+ for session in recent_sessions:+ start = session.connected_at or session.connected_at+ end = session.disconnected_at or datetime.utcnow()+ uptime_seconds += (end - start).total_seconds()++ # Queued commands for this server+ queued = ServerCommand.query.filter_by(+ server_id=server_id, queued=True, status='pending'+ ).count()++ return {+ 'server_id': server_id,+ 'server_name': server.name,+ 'status': server.status,+ 'agent_version': server.agent_version,+ 'last_seen': server.last_seen.isoformat() if server.last_seen else None,+ 'connection': {+ 'is_connected': active_session is not None,+ 'current_latency_ms': active_session.heartbeat_latency_ms if active_session else None,+ 'avg_latency_ms': active_session.avg_latency_ms if active_session else None,+ 'connected_since': active_session.connected_at.isoformat() if active_session else None,+ 'ip_address': active_session.ip_address if active_session else server.ip_address,+ },+ 'commands_24h': {+ 'total': total_cmds,+ 'success': success_cmds,+ 'failed': failed_cmds,+ 'timeout': timeout_cmds,+ 'success_rate': round((success_cmds / total_cmds * 100), 1) if total_cmds > 0 else 100.0,+ },+ 'queued_commands': queued,+ 'uptime_seconds_24h': round(uptime_seconds),+ 'recent_sessions': [s.to_dict() for s in recent_sessions],+ }+++fleet_service = AgentFleetService()diff --git a/backend/app/services/agent_registry.py b/backend/app/services/agent_registry.pyindex db298454..946df8a5 100644--- a/backend/app/services/agent_registry.py+++ b/backend/app/services/agent_registry.py@@ -211,6 +211,14 @@ class AgentRegistry:)db.session.add(session)db.session.commit()++ # Deliver any queued commands for this server+ try:+ from app.services.agent_fleet_service import fleet_service+ fleet_service.deliver_queued_commands(server_id)+ except Exception as e:+ print(f"Error delivering queued commands: {e}")+except Exception as e:print(f"Error registering agent: {e}")db.session.rollback()@@ -272,22 +280,39 @@ class AgentRegistry:# ==================== Heartbeat ====================- def update_heartbeat(self, server_id: str, metrics: dict = None):+ def update_heartbeat(self, server_id: str, metrics: dict = None, client_timestamp: int = None):"""Update agent heartbeat and optionally store metrics"""+ now = datetime.utcnow()with self._lock:agent = self._agents.get(server_id)if agent:- agent.last_heartbeat = datetime.utcnow()+ agent.last_heartbeat = now++ # Calculate heartbeat latency if client sent a timestamp+ latency_ms = None+ if client_timestamp:+ now_ms = int(time.time() * 1000)+ latency_ms = max(0, now_ms - client_timestamp)# Update server last_seentry:server = Server.query.get(server_id)if server:- server.last_seen = datetime.utcnow()+ server.last_seen = nowif server.status != 'online':server.status = 'online'db.session.commit()+ # Update session latency+ if latency_ms is not None:+ session = AgentSession.query.filter_by(+ server_id=server_id, is_active=True+ ).first()+ if session:+ session.last_heartbeat = now+ session.update_latency(latency_ms)+ db.session.commit()+# Store metrics if providedif metrics:self._store_metrics(server_id, metrics)diff --git a/backend/app/services/discovery_service.py b/backend/app/services/discovery_service.pynew file mode 100644index 00000000..f6229ca6--- /dev/null+++ b/backend/app/services/discovery_service.py@@ -0,0 +1,113 @@+"""+Discovery Service++Handles auto-discovery of new servers on the local network.+Uses UDP broadcast to find agents.+"""++import socket+import json+import threading+import time+from datetime import datetime+from typing import List, Dict++from app import db+from app.models.server import Server+++class DiscoveryService:+ """+ Service for discovering new servers/agents on the network.+ """++ def __init__(self, port=9000):+ self.port = port+ self._discovered_agents = {} # agent_id -> info+ self._is_scanning = False+ self._lock = threading.Lock()++ def start_scan(self, duration=10) -> List[Dict]:+ """+ Start a network scan for agents.+ """+ if self._is_scanning:+ return list(self._discovered_agents.values())++ self._is_scanning = True+ self._discovered_agents = {}++ # Start listening thread+ listen_thread = threading.Thread(target=self._listen_for_responses, daemon=True)+ listen_thread.start()++ # Send broadcast requests+ self._send_broadcast_request()++ # Wait for duration+ time.sleep(duration)++ self._is_scanning = False+ return list(self._discovered_agents.values())++ def _send_broadcast_request(self):+ """Send UDP broadcast request to discover agents"""+ try:+ sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)+ sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)+ sock.settimeout(2)++ message = json.dumps({+ 'type': 'discovery_request',+ 'timestamp': int(time.time() * 1000)+ })++ # Broadcast to common local networks+ sock.sendto(message.encode(), ('255.255.255.255', self.port))+ sock.close()+ except Exception as e:+ print(f"Error sending discovery broadcast: {e}")++ def _listen_for_responses(self):+ """Listen for UDP discovery responses from agents"""+ try:+ sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)+ sock.bind(('', self.port + 1)) # Listen on port + 1+ sock.settimeout(1)++ start_time = time.time()+ while self._is_scanning:+ try:+ data, addr = sock.recvfrom(4096)+ try:+ info = json.loads(data.decode())+ if info.get('type') == 'discovery':+ agent_id = info.get('agent_id')+ if agent_id:+ # Add IP address from sender+ info['ip_address'] = addr[0]++ # Check if already registered+ server = Server.query.filter_by(agent_id=agent_id).first()+ info['is_registered'] = server is not None+ if server:+ info['server_name'] = server.name+ info['server_id'] = server.id++ with self._lock:+ self._discovered_agents[agent_id] = info+ except Exception as e:+ print(f"Error parsing discovery response: {e}")+ except socket.timeout:+ continue+ sock.close()+ except Exception as e:+ print(f"Error in discovery listener: {e}")++ def get_discovered_agents(self) -> List[Dict]:+ """Get currently discovered agents"""+ with self._lock:+ return list(self._discovered_agents.values())+++discovery_service = DiscoveryService()diff --git a/frontend/src/App.jsx b/frontend/src/App.jsxindex 511ab200..2ffbe0d1 100644--- a/frontend/src/App.jsx+++ b/frontend/src/App.jsx@@ -31,6 +31,7 @@ import Templates from './pages/Templates';import WorkflowBuilder from './pages/WorkflowBuilder';import Servers from './pages/Servers';import ServerDetail from './pages/ServerDetail';+import AgentFleet from './pages/AgentFleet';import Downloads from './pages/Downloads';import WordPress from './pages/WordPress';import WordPressDetail from './pages/WordPressDetail';@@ -204,6 +205,7 @@ function AppRoutes() {<Route path="servers" element={<Servers />} /><Route path="servers/:id" element={<ServerDetail />} /><Route path="servers/:id/:tab" element={<ServerDetail />} />+ <Route path="fleet" element={<AgentFleet />} /><Route path="downloads" element={<Downloads />} /><Route path="firewall" element={<Navigate to="/security/firewall" replace />} /><Route path="git" element={<Git />} />diff --git a/frontend/src/components/sidebarItems.js b/frontend/src/components/sidebarItems.jsindex ce1409f0..135bde6e 100644--- a/frontend/src/components/sidebarItems.js+++ b/frontend/src/components/sidebarItems.js@@ -28,6 +28,13 @@ export const SIDEBAR_ITEMS = [category: 'infrastructure',icon: '<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"/>'},+ {+ id: 'fleet',+ label: 'Agent Fleet',+ route: '/fleet',+ category: 'infrastructure',+ icon: '<path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M23 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/>'+ },{id: 'domains',label: 'Domains & Sites',diff --git a/frontend/src/pages/AgentFleet.jsx b/frontend/src/pages/AgentFleet.jsxnew file mode 100644index 00000000..09042a85--- /dev/null+++ b/frontend/src/pages/AgentFleet.jsx@@ -0,0 +1,862 @@+import React, { useState, useEffect, useCallback } from 'react';+import {+ Users,+ Shield,+ Activity,+ Download,+ RefreshCw,+ CheckCircle,+ AlertCircle,+ Clock,+ Zap,+ Search,+ ChevronRight,+ Server,+ Layers,+ Package,+ Plus,+ Trash2,+ Play,+ Pause,+ XCircle,+ Wifi,+ WifiOff,+ RotateCcw,+ Info+} from 'lucide-react';+import api from '../services/api';+import { useToast } from '../contexts/ToastContext';+import { useAuth } from '../contexts/AuthContext';++const AgentFleet = () => {+ const [activeTab, setActiveTab] = useState('dashboard');+ const [loading, setLoading] = useState(true);+ const [health, setHealth] = useState(null);+ const [versions, setVersions] = useState([]);+ const [discoveredAgents, setDiscoveredAgents] = useState([]);+ const [pendingServers, setPendingServers] = useState([]);+ const [rollouts, setRollouts] = useState([]);+ const [queuedCommands, setQueuedCommands] = useState([]);+ const [diagnostics, setDiagnostics] = useState(null);+ const [diagnosticsServerId, setDiagnosticsServerId] = useState('');+ const [isScanning, setIsScanning] = useState(false);+ const [selectedVersion, setSelectedVersion] = useState('');+ const [rolloutStrategy, setRolloutStrategy] = useState('all');+ const [rolloutBatchSize, setRolloutBatchSize] = useState(5);+ const [rolloutDelay, setRolloutDelay] = useState(10);+ const { addToast } = useToast();+ const { user } = useAuth();++ useEffect(() => {+ fetchData();+ }, [activeTab]);++ const fetchData = async () => {+ setLoading(true);+ try {+ if (activeTab === 'dashboard') {+ const data = await api.getFleetHealth();+ setHealth(data);+ } else if (activeTab === 'versions') {+ const data = await api.getAgentVersions();+ setVersions(data);+ } else if (activeTab === 'rollouts') {+ const [rolloutData, versionData] = await Promise.all([+ api.getRollouts(),+ api.getAgentVersions()+ ]);+ setRollouts(rolloutData);+ setVersions(versionData);+ if (versionData.length > 0 && !selectedVersion) {+ setSelectedVersion(versionData[0].id);+ }+ } else if (activeTab === 'discovery') {+ const data = await api.getDiscoveredAgents();+ setDiscoveredAgents(data);+ } else if (activeTab === 'approvals') {+ const data = await api.getServers();+ setPendingServers((data.servers || data).filter(s => s.status === 'pending'));+ } else if (activeTab === 'queue') {+ const data = await api.getQueuedCommands();+ setQueuedCommands(data);+ }+ } catch (error) {+ console.error('Error fetching fleet data:', error);+ addToast('Error', 'Failed to fetch fleet data', 'error');+ } finally {+ setLoading(false);+ }+ };++ const startDiscovery = async () => {+ setIsScanning(true);+ try {+ addToast('Discovery', 'Scanning network for agents...', 'info');+ await api.startDiscovery(10);+ const data = await api.getDiscoveredAgents();+ setDiscoveredAgents(data);+ addToast('Success', `Discovered ${data.length} agents`, 'success');+ } catch (error) {+ addToast('Error', 'Discovery scan failed', 'error');+ } finally {+ setIsScanning(false);+ }+ };++ const approveAgent = async (serverId) => {+ try {+ await api.approveRegistration(serverId);+ addToast('Success', 'Agent registration approved', 'success');+ fetchData();+ } catch (error) {+ addToast('Error', 'Failed to approve agent', 'error');+ }+ };++ const rejectAgent = async (serverId) => {+ try {+ await api.rejectRegistration(serverId);+ addToast('Success', 'Agent registration rejected', 'success');+ fetchData();+ } catch (error) {+ addToast('Error', 'Failed to reject agent', 'error');+ }+ };++ const triggerUpgrade = async () => {+ if (!selectedVersion) {+ addToast('Error', 'Select a target version', 'error');+ return;+ }++ try {+ if (rolloutStrategy === 'all') {+ await api.upgradeFleet([], selectedVersion);+ addToast('Success', 'Upgrade triggered for all online agents', 'success');+ } else {+ const data = {+ version_id: selectedVersion,+ strategy: rolloutStrategy,+ batch_size: rolloutStrategy === 'canary' ? 1 : rolloutBatchSize,+ delay_minutes: rolloutDelay+ };+ await api.startRollout(data);+ addToast('Success', 'Staged rollout started', 'success');+ }+ fetchData();+ } catch (error) {+ addToast('Error', 'Failed to trigger upgrade', 'error');+ }+ };++ const cancelRollout = async (rolloutId) => {+ try {+ await api.cancelRollout(rolloutId);+ addToast('Success', 'Rollout cancelled', 'success');+ fetchData();+ } catch (error) {+ addToast('Error', 'Failed to cancel rollout', 'error');+ }+ };++ const retryCommand = async (commandId) => {+ try {+ await api.retryCommand(commandId);+ addToast('Success', 'Command retry triggered', 'success');+ fetchData();+ } catch (error) {+ addToast('Error', 'Failed to retry command', 'error');+ }+ };++ const loadDiagnostics = async (serverId) => {+ try {+ const data = await api.getServerDiagnostics(serverId);+ setDiagnostics(data);+ setDiagnosticsServerId(serverId);+ } catch (error) {+ addToast('Error', 'Failed to load diagnostics', 'error');+ }+ };++ const rolloutStatusBadge = (status) => {+ const map = {+ running: 'badge-info',+ completed: 'badge-success',+ failed: 'badge-error',+ cancelled: 'badge-warning',+ pending: 'badge-default'+ };+ return map[status] || 'badge-default';+ };++ return (+ <div className="page-container">+ <div className="page-header">+ <div className="header-info">+ <h1>Agent Fleet Management</h1>+ <p>Monitor health, manage versions, and control updates across your infrastructure.</p>+ </div>+ <div className="header-actions">+ <button+ className="btn btn-primary"+ onClick={fetchData}+ disabled={loading}+ >+ <RefreshCw size={18} className={loading ? 'animate-spin' : ''} />+ Refresh+ </button>+ </div>+ </div>++ <div className="tabs-container">+ <div className="tabs">+ {[+ { key: 'dashboard', icon: Activity, label: 'Dashboard' },+ { key: 'versions', icon: Package, label: 'Versions' },+ { key: 'rollouts', icon: Zap, label: 'Rollouts' },+ { key: 'queue', icon: Clock, label: 'Command Queue' },+ { key: 'discovery', icon: Search, label: 'Discovery' },+ { key: 'approvals', icon: Shield, label: 'Approvals' },+ ].map(tab => (+ <button+ key={tab.key}+ className={`tab ${activeTab === tab.key ? 'active' : ''}`}+ onClick={() => setActiveTab(tab.key)}+ >+ <tab.icon size={18} />+ {tab.label}+ {tab.key === 'approvals' && pendingServers.length > 0 && (+ <span className="badge badge-error ml-2">{pendingServers.length}</span>+ )}+ {tab.key === 'queue' && queuedCommands.length > 0 && (+ <span className="badge badge-warning ml-2">{queuedCommands.length}</span>+ )}+ </button>+ ))}+ </div>+ </div>++ <div className="tab-content mt-6">+ {/* ==================== Dashboard ==================== */}+ {activeTab === 'dashboard' && health && (+ <div className="space-y-6">+ <div className="grid grid-cols-1 md:grid-cols-4 gap-4">+ <div className="stat-card">+ <div className="stat-icon bg-blue-100 text-blue-600">+ <Server size={24} />+ </div>+ <div className="stat-content">+ <div className="stat-value">{health.total_servers}</div>+ <div className="stat-label">Total Agents</div>+ </div>+ </div>+ <div className="stat-card">+ <div className="stat-icon bg-green-100 text-green-600">+ <CheckCircle size={24} />+ </div>+ <div className="stat-content">+ <div className="stat-value">{health.online_servers}</div>+ <div className="stat-label">Online</div>+ </div>+ </div>+ <div className="stat-card">+ <div className="stat-icon bg-red-100 text-red-600">+ <AlertCircle size={24} />+ </div>+ <div className="stat-content">+ <div className="stat-value">{health.offline_servers}</div>+ <div className="stat-label">Offline</div>+ </div>+ </div>+ <div className="stat-card">+ <div className="stat-icon bg-purple-100 text-purple-600">+ <Zap size={24} />+ </div>+ <div className="stat-content">+ <div className="stat-value">{health.command_success_rate}%</div>+ <div className="stat-label">Success Rate</div>+ </div>+ </div>+ </div>++ <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">+ <div className="card">+ <div className="card-header">+ <h2>Fleet Health Summary</h2>+ </div>+ <div className="card-body">+ <div className="space-y-4">+ <div className="flex justify-between items-center">+ <span className="text-gray-600">Overall Uptime</span>+ <span className="font-semibold text-green-600">{health.uptime_percentage?.toFixed(2)}%</span>+ </div>+ <div className="w-full bg-gray-200 rounded-full h-2">+ <div+ className="bg-green-600 h-2 rounded-full"+ style={{ width: `${health.uptime_percentage}%` }}+ ></div>+ </div>++ <div className="flex justify-between items-center mt-6">+ <span className="text-gray-600">Avg Heartbeat Latency</span>+ <span className="font-semibold">{health.avg_heartbeat_latency} ms</span>+ </div>+ <div className="w-full bg-gray-200 rounded-full h-2">+ <div+ className="bg-blue-600 h-2 rounded-full"+ style={{ width: `${Math.min(100, health.avg_heartbeat_latency / 2)}%` }}+ ></div>+ </div>++ {health.queued_commands > 0 && (+ <div className="flex justify-between items-center mt-4 p-3 bg-yellow-50 rounded-lg">+ <span className="text-yellow-700 flex items-center gap-2">+ <Clock size={16} /> Queued Commands+ </span>+ <span className="font-semibold text-yellow-700">{health.queued_commands}</span>+ </div>+ )}+ </div>+ </div>+ </div>++ <div className="card">+ <div className="card-header">+ <h2>Version Distribution</h2>+ </div>+ <div className="card-body">+ <div className="space-y-4">+ {Object.entries(health.version_distribution || {}).map(([version, count]) => (+ <div key={version} className="space-y-1">+ <div className="flex justify-between text-sm">+ <span>v{version}</span>+ <span className="text-gray-500">{count} agents ({(count / health.total_servers * 100).toFixed(0)}%)</span>+ </div>+ <div className="w-full bg-gray-200 rounded-full h-2">+ <div+ className="bg-indigo-600 h-2 rounded-full"+ style={{ width: `${count / health.total_servers * 100}%` }}+ ></div>+ </div>+ </div>+ ))}+ {Object.keys(health.version_distribution || {}).length === 0 && (+ <p className="text-gray-500 text-center py-4">No agents registered yet.</p>+ )}+ </div>+ </div>+ </div>+ </div>+ </div>+ )}++ {/* ==================== Versions ==================== */}+ {activeTab === 'versions' && (+ <div className="card">+ <div className="card-header flex justify-between items-center">+ <h2>Agent Versions</h2>+ <button className="btn btn-sm btn-primary">+ <Plus size={16} /> Add Version+ </button>+ </div>+ <div className="overflow-x-auto">+ <table className="table">+ <thead>+ <tr>+ <th>Version</th>+ <th>Channel</th>+ <th>Published</th>+ <th>Panel Compatibility</th>+ <th>Status</th>+ <th>Actions</th>+ </tr>+ </thead>+ <tbody>+ {versions.map(v => (+ <tr key={v.id}>+ <td className="font-semibold">v{v.version}</td>+ <td>+ <span className={`badge ${v.channel === 'stable' ? 'badge-success' : 'badge-warning'}`}>+ {v.channel}+ </span>+ </td>+ <td>{new Date(v.published_at).toLocaleDateString()}</td>+ <td>{v.min_panel_version || 'Any'} - {v.max_panel_version || 'Latest'}</td>+ <td>+ <span className={`flex items-center gap-1 ${v.is_active ? 'text-green-600' : 'text-gray-400'}`}>+ {v.is_active ? <CheckCircle size={14} /> : <Clock size={14} />}+ {v.is_active ? 'Active' : 'Inactive'}+ </span>+ </td>+ <td className="actions">+ <button className="btn btn-ghost btn-sm" title="Edit"><RefreshCw size={14} /></button>+ <button className="btn btn-ghost btn-sm text-red-600" title="Delete"><Trash2 size={14} /></button>+ </td>+ </tr>+ ))}+ {versions.length === 0 && (+ <tr>+ <td colSpan="6" className="text-center py-8 text-gray-500">+ No agent versions registered in database.+ </td>+ </tr>+ )}+ </tbody>+ </table>+ </div>+ {versions.length > 0 && versions[0].release_notes && (+ <div className="card-body border-t">+ <h3 className="text-sm font-semibold mb-2">Latest Release Notes (v{versions[0].version})</h3>+ <p className="text-sm text-gray-600 whitespace-pre-wrap">{versions[0].release_notes}</p>+ </div>+ )}+ </div>+ )}++ {/* ==================== Rollouts ==================== */}+ {activeTab === 'rollouts' && (+ <div className="space-y-6">+ <div className="card">+ <div className="card-header">+ <h2>Trigger Fleet Upgrade</h2>+ </div>+ <div className="card-body">+ <p className="text-gray-600 mb-4">+ Push a specific agent version to multiple servers at once.+ </p>+ <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4">+ <div className="form-group">+ <label>Target Version</label>+ <select+ className="form-select w-full"+ value={selectedVersion}+ onChange={e => setSelectedVersion(e.target.value)}+ >+ <option value="">Select version...</option>+ {versions.map(v => (+ <option key={v.id} value={v.id}>v{v.version} ({v.channel})</option>+ ))}+ </select>+ </div>+ <div className="form-group">+ <label>Rollout Strategy</label>+ <select+ className="form-select w-full"+ value={rolloutStrategy}+ onChange={e => setRolloutStrategy(e.target.value)}+ >+ <option value="all">All At Once</option>+ <option value="staged">Staged (Batch by Batch)</option>+ <option value="canary">Canary (1 server first)</option>+ </select>+ </div>+ {rolloutStrategy === 'staged' && (+ <>+ <div className="form-group">+ <label>Batch Size</label>+ <input+ type="number"+ className="form-input w-full"+ value={rolloutBatchSize}+ onChange={e => setRolloutBatchSize(parseInt(e.target.value) || 5)}+ min={1}+ />+ </div>+ <div className="form-group">+ <label>Delay (minutes)</label>+ <input+ type="number"+ className="form-input w-full"+ value={rolloutDelay}+ onChange={e => setRolloutDelay(parseInt(e.target.value) || 10)}+ min={1}+ />+ </div>+ </>+ )}+ </div>+ <div className="mt-6 flex justify-end">+ <button+ className="btn btn-primary"+ onClick={triggerUpgrade}+ disabled={!selectedVersion}+ >+ <Play size={18} /> Start Rollout+ </button>+ </div>+ </div>+ </div>++ <div className="card">+ <div className="card-header">+ <h2>Rollout History</h2>+ </div>+ {rollouts.length > 0 ? (+ <div className="overflow-x-auto">+ <table className="table">+ <thead>+ <tr>+ <th>Version</th>+ <th>Strategy</th>+ <th>Progress</th>+ <th>Status</th>+ <th>Started</th>+ <th>Actions</th>+ </tr>+ </thead>+ <tbody>+ {rollouts.map(r => (+ <tr key={r.id}>+ <td className="font-semibold">v{r.version}</td>+ <td>{r.strategy}</td>+ <td>+ <div className="flex items-center gap-3">+ <div className="w-24 bg-gray-200 rounded-full h-2">+ <div+ className={`h-2 rounded-full ${r.status === 'failed' ? 'bg-red-500' : r.status === 'completed' ? 'bg-green-500' : 'bg-blue-500'}`}+ style={{ width: `${r.total_servers > 0 ? (r.processed_servers / r.total_servers * 100) : 0}%` }}+ ></div>+ </div>+ <span className="text-sm text-gray-500">+ {r.processed_servers}/{r.total_servers}+ {r.failed_servers > 0 && (+ <span className="text-red-500 ml-1">({r.failed_servers} failed)</span>+ )}+ </span>+ </div>+ </td>+ <td>+ <span className={`badge ${rolloutStatusBadge(r.status)}`}>+ {r.status}+ </span>+ </td>+ <td className="text-sm">{r.started_at ? new Date(r.started_at).toLocaleString() : '-'}</td>+ <td className="actions">+ {r.status === 'running' && (+ <button+ className="btn btn-sm btn-ghost text-red-600"+ onClick={() => cancelRollout(r.id)}+ title="Cancel Rollout"+ >+ <XCircle size={14} /> Cancel+ </button>+ )}+ {r.error && (+ <span className="text-xs text-red-500" title={r.error}>+ <AlertCircle size={14} />+ </span>+ )}+ </td>+ </tr>+ ))}+ </tbody>+ </table>+ </div>+ ) : (+ <div className="card-body py-12 text-center text-gray-500">+ <Zap size={48} className="mx-auto text-gray-300 mb-4" />+ <p>No rollouts have been started yet.</p>+ </div>+ )}+ </div>+ </div>+ )}++ {/* ==================== Command Queue ==================== */}+ {activeTab === 'queue' && (+ <div className="card">+ <div className="card-header flex justify-between items-center">+ <h2>Queued Commands</h2>+ <p className="text-sm text-gray-500">Commands waiting to be delivered when agents reconnect</p>+ </div>+ {queuedCommands.length > 0 ? (+ <div className="overflow-x-auto">+ <table className="table">+ <thead>+ <tr>+ <th>Server</th>+ <th>Command</th>+ <th>Retries</th>+ <th>Queued At</th>+ <th>Actions</th>+ </tr>+ </thead>+ <tbody>+ {queuedCommands.map(cmd => (+ <tr key={cmd.id}>+ <td>{cmd.server_id?.slice(0, 8)}...</td>+ <td className="font-mono text-sm">{cmd.command_type}</td>+ <td>+ <span className={cmd.retry_count > 0 ? 'text-yellow-600' : ''}>+ {cmd.retry_count}/{cmd.max_retries}+ </span>+ </td>+ <td className="text-sm">{new Date(cmd.created_at).toLocaleString()}</td>+ <td className="actions">+ <button+ className="btn btn-sm btn-ghost"+ onClick={() => retryCommand(cmd.id)}+ title="Retry now"+ >+ <RotateCcw size={14} /> Retry+ </button>+ </td>+ </tr>+ ))}+ </tbody>+ </table>+ </div>+ ) : (+ <div className="card-body py-12 text-center text-gray-500">+ <CheckCircle size={48} className="mx-auto text-gray-300 mb-4" />+ <p>No queued commands. All agents are up to date.</p>+ </div>+ )}+ </div>+ )}++ {/* ==================== Discovery ==================== */}+ {activeTab === 'discovery' && (+ <div className="space-y-6">+ <div className="flex justify-between items-center">+ <h2>Network Discovery</h2>+ <button+ className="btn btn-primary"+ onClick={startDiscovery}+ disabled={isScanning}+ >+ {isScanning ? <RefreshCw size={18} className="animate-spin" /> : <Search size={18} />}+ {isScanning ? 'Scanning...' : 'Start Scan'}+ </button>+ </div>++ <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">+ {discoveredAgents.map(agent => (+ <div key={agent.agent_id} className="card p-4 flex flex-col justify-between">+ <div>+ <div className="flex justify-between items-start mb-2">+ <div className="bg-blue-100 p-2 rounded text-blue-600">+ <Server size={20} />+ </div>+ {agent.is_registered ? (+ <span className="badge badge-success">Registered</span>+ ) : (+ <span className="badge badge-warning">New</span>+ )}+ </div>+ <h3 className="font-bold">{agent.hostname}</h3>+ <p className="text-sm text-gray-500">{agent.ip_address}</p>+ <div className="mt-4 space-y-2 text-sm">+ <div className="flex justify-between">+ <span className="text-gray-500">OS:</span>+ <span>{agent.os} ({agent.arch})</span>+ </div>+ <div className="flex justify-between">+ <span className="text-gray-500">Agent Version:</span>+ <span>v{agent.agent_version}</span>+ </div>+ </div>+ </div>+ <div className="mt-4 pt-4 border-t">+ {agent.is_registered ? (+ <button+ className="btn btn-sm btn-ghost w-full"+ onClick={() => {+ setActiveTab('dashboard');+ loadDiagnostics(agent.server_id);+ }}+ >+ View Details+ </button>+ ) : (+ <button className="btn btn-sm btn-primary w-full">Add to Fleet</button>+ )}+ </div>+ </div>+ ))}+ {discoveredAgents.length === 0 && !isScanning && (+ <div className="col-span-full py-12 text-center card bg-gray-50">+ <Search size={48} className="mx-auto text-gray-300 mb-4" />+ <p className="text-gray-500">No agents discovered yet. Start a scan to find agents on your local network.</p>+ </div>+ )}+ </div>+ </div>+ )}++ {/* ==================== Approvals ==================== */}+ {activeTab === 'approvals' && (+ <div className="card">+ <div className="card-header">+ <h2>Pending Registrations</h2>+ </div>+ <div className="overflow-x-auto">+ <table className="table">+ <thead>+ <tr>+ <th>Server Name</th>+ <th>IP Address</th>+ <th>Requested</th>+ <th>Agent Version</th>+ <th>Actions</th>+ </tr>+ </thead>+ <tbody>+ {pendingServers.map(server => (+ <tr key={server.id}>+ <td className="font-semibold">{server.name}</td>+ <td>{server.ip_address || 'N/A'}</td>+ <td>{new Date(server.created_at).toLocaleString()}</td>+ <td>v{server.agent_version || 'Unknown'}</td>+ <td className="actions">+ <button+ className="btn btn-sm btn-success flex items-center gap-1"+ onClick={() => approveAgent(server.id)}+ >+ <CheckCircle size={14} /> Approve+ </button>+ <button+ className="btn btn-sm btn-ghost text-red-600"+ onClick={() => rejectAgent(server.id)}+ >+ <XCircle size={14} /> Reject+ </button>+ </td>+ </tr>+ ))}+ {pendingServers.length === 0 && (+ <tr>+ <td colSpan="5" className="text-center py-8 text-gray-500">+ No pending agent registrations.+ </td>+ </tr>+ )}+ </tbody>+ </table>+ </div>+ </div>+ )}++ {/* ==================== Diagnostics Modal ==================== */}+ {diagnostics && (+ <div className="fixed inset-0 z-50 flex items-center justify-center bg-black bg-opacity-50" onClick={() => setDiagnostics(null)}>+ <div className="bg-white rounded-lg shadow-xl w-full max-w-2xl max-h-[80vh] overflow-y-auto m-4" onClick={e => e.stopPropagation()}>+ <div className="p-6 border-b flex justify-between items-center">+ <h2 className="text-lg font-semibold">+ Agent Diagnostics - {diagnostics.server_name}+ </h2>+ <button className="btn btn-ghost btn-sm" onClick={() => setDiagnostics(null)}>+ <XCircle size={18} />+ </button>+ </div>+ <div className="p-6 space-y-6">+ <div className="grid grid-cols-2 gap-4">+ <div>+ <label className="text-sm text-gray-500">Status</label>+ <p className="font-semibold flex items-center gap-2">+ {diagnostics.connection.is_connected ? (+ <><Wifi size={16} className="text-green-500" /> Connected</>+ ) : (+ <><WifiOff size={16} className="text-red-500" /> Disconnected</>+ )}+ </p>+ </div>+ <div>+ <label className="text-sm text-gray-500">Agent Version</label>+ <p className="font-semibold">v{diagnostics.agent_version || 'Unknown'}</p>+ </div>+ <div>+ <label className="text-sm text-gray-500">Current Latency</label>+ <p className="font-semibold">+ {diagnostics.connection.current_latency_ms != null+ ? `${diagnostics.connection.current_latency_ms.toFixed(1)} ms`+ : 'N/A'}+ </p>+ </div>+ <div>+ <label className="text-sm text-gray-500">Avg Latency</label>+ <p className="font-semibold">+ {diagnostics.connection.avg_latency_ms != null+ ? `${diagnostics.connection.avg_latency_ms.toFixed(1)} ms`+ : 'N/A'}+ </p>+ </div>+ <div>+ <label className="text-sm text-gray-500">IP Address</label>+ <p className="font-semibold">{diagnostics.connection.ip_address || 'N/A'}</p>+ </div>+ <div>+ <label className="text-sm text-gray-500">Connected Since</label>+ <p className="font-semibold">+ {diagnostics.connection.connected_since+ ? new Date(diagnostics.connection.connected_since).toLocaleString()+ : 'N/A'}+ </p>+ </div>+ </div>++ <div>+ <h3 className="font-semibold mb-3">Command Stats (24h)</h3>+ <div className="grid grid-cols-4 gap-3">+ <div className="text-center p-3 bg-gray-50 rounded">+ <div className="text-lg font-bold">{diagnostics.commands_24h.total}</div>+ <div className="text-xs text-gray-500">Total</div>+ </div>+ <div className="text-center p-3 bg-green-50 rounded">+ <div className="text-lg font-bold text-green-600">{diagnostics.commands_24h.success}</div>+ <div className="text-xs text-gray-500">Success</div>+ </div>+ <div className="text-center p-3 bg-red-50 rounded">+ <div className="text-lg font-bold text-red-600">{diagnostics.commands_24h.failed}</div>+ <div className="text-xs text-gray-500">Failed</div>+ </div>+ <div className="text-center p-3 bg-yellow-50 rounded">+ <div className="text-lg font-bold text-yellow-600">{diagnostics.commands_24h.timeout}</div>+ <div className="text-xs text-gray-500">Timeout</div>+ </div>+ </div>+ </div>++ {diagnostics.queued_commands > 0 && (+ <div className="p-3 bg-yellow-50 border border-yellow-200 rounded-lg flex items-center gap-2">+ <Clock size={16} className="text-yellow-600" />+ <span className="text-sm text-yellow-700">+ {diagnostics.queued_commands} commands queued for delivery+ </span>+ </div>+ )}++ <div>+ <h3 className="font-semibold mb-3">Recent Sessions</h3>+ <div className="space-y-2 max-h-48 overflow-y-auto">+ {diagnostics.recent_sessions.map(session => (+ <div key={session.id} className="flex justify-between items-center text-sm p-2 bg-gray-50 rounded">+ <div className="flex items-center gap-2">+ {session.is_active ? (+ <Wifi size={14} className="text-green-500" />+ ) : (+ <WifiOff size={14} className="text-gray-400" />+ )}+ <span>{session.ip_address}</span>+ </div>+ <div className="text-gray-500">+ {new Date(session.connected_at).toLocaleString()}+ {session.disconnect_reason && (+ <span className="ml-2 text-red-500">({session.disconnect_reason})</span>+ )}+ </div>+ </div>+ ))}+ </div>+ </div>+ </div>+ </div>+ </div>+ )}+ </div>+ </div>+ );+};++export default AgentFleet;diff --git a/frontend/src/services/api.js b/frontend/src/services/api.jsindex bdce5b5b..16de7e5f 100644--- a/frontend/src/services/api.js+++ b/frontend/src/services/api.js@@ -2941,6 +2941,90 @@ class ApiService {return `${baseUrl}/api/servers/agent/download/${os}/${arch}`;}+ // ========================================+ // Agent Fleet Management endpoints+ // ========================================+ async getFleetHealth() {+ return this.request('/servers/fleet/health');+ }++ async getAgentVersions() {+ return this.request('/servers/fleet/versions');+ }++ async addAgentVersion(data) {+ return this.request('/servers/fleet/versions', {+ method: 'POST',+ body: data+ });+ }++ async upgradeFleet(serverIds, versionId) {+ return this.request('/servers/fleet/upgrade', {+ method: 'POST',+ body: { server_ids: serverIds, version_id: versionId }+ });+ }++ async startRollout(data) {+ return this.request('/servers/fleet/rollout', {+ method: 'POST',+ body: data+ });+ }++ async getRollouts(status) {+ const query = status ? `?status=${status}` : '';+ return this.request(`/servers/fleet/rollouts${query}`);+ }++ async getRollout(rolloutId) {+ return this.request(`/servers/fleet/rollouts/${rolloutId}`);+ }++ async cancelRollout(rolloutId) {+ return this.request(`/servers/fleet/rollouts/${rolloutId}/cancel`, {+ method: 'POST'+ });+ }++ async startDiscovery(duration = 10) {+ return this.request(`/servers/fleet/discovery?duration=${duration}`, {+ method: 'POST'+ });+ }++ async getDiscoveredAgents() {+ return this.request('/servers/fleet/discovery');+ }++ async approveRegistration(serverId) {+ return this.request(`/servers/fleet/approve/${serverId}`, {+ method: 'POST'+ });+ }++ async rejectRegistration(serverId) {+ return this.request(`/servers/fleet/reject/${serverId}`, {+ method: 'POST'+ });+ }++ async getQueuedCommands(serverId) {+ const query = serverId ? `?server_id=${serverId}` : '';+ return this.request(`/servers/fleet/commands/queued${query}`);+ }++ async retryCommand(commandId) {+ return this.request(`/servers/fleet/commands/${commandId}/retry`, {+ method: 'POST'+ });+ }++ async getServerDiagnostics(serverId) {+ return this.request(`/servers/fleet/diagnostics/${serverId}`);+ }+// ── Email Server ──async getEmailStatus() { return this.request('/email/status'); }async installEmailServer(data = {}) { return this.request('/email/install', { method: 'POST', body: JSON.stringify(data) }); }