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 agent fleet management, discovery & updates

Juan Denisd9dfc4d611b0
diff --git a/.gitignore b/.gitignore
index ad077178..229390f8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -93,3 +93,4 @@ new_templates/
/logs/
/tmp/
nul
+SECURITY_AUDIT.md
diff --git a/agent/internal/agent/agent.go b/agent/internal/agent/agent.go
index 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 commands
if a.terminal != nil {
a.handlers[protocol.ActionTerminalCreate] = a.handleTerminalCreate
@@ -158,6 +168,9 @@ func (a *Agent) registerHandlers() {
a.handlers[protocol.ActionTerminalResize] = a.handleTerminalResize
a.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 loop
go a.heartbeatLoop(ctx)
+ // Start discovery responder
+ go a.discoveryLoop(ctx)
+
// Wait for context cancellation or restart request
select {
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 heartbeats
func (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.go
index 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 available
func (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.go
index 9d039dbb..db07f43f 100644
--- a/agent/pkg/protocol/messages.go
+++ b/agent/pkg/protocol/messages.go
@@ -33,6 +33,10 @@ const (
// System
TypeSystemInfo MessageType = "system_info"
+ // Discovery
+ TypeDiscovery MessageType = "discovery"
+ TypeDiscoveryRequest MessageType = "discovery_request"
+
// Credential Rotation
TypeCredentialUpdate 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 channels
diff --git a/backend/app/api/servers.py b/backend/app/api/servers.py
index 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_identity
from app import db
from 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, AgentRollout
from app.services.agent_registry import agent_registry
+from app.services.agent_fleet_service import fleet_service
+from app.services.discovery_service import discovery_service
from app.middleware.rbac import admin_required, developer_required
servers_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__.py
index 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 AuditLog
from app.models.metrics_history import MetricsHistory
from app.models.workflow import Workflow, WorkflowExecution, WorkflowLog
from 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, AgentRollout
from app.models.security_alert import SecurityAlert
from app.models.wordpress_site import WordPressSite, DatabaseSnapshot, SyncJob
from 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.py
index 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 name
parent_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 Info
agent_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.py
new file mode 100644
index 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.py
index 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_seen
try:
server = Server.query.get(server_id)
if server:
- server.last_seen = datetime.utcnow()
+ server.last_seen = now
if 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 provided
if metrics:
self._store_metrics(server_id, metrics)
diff --git a/backend/app/services/discovery_service.py b/backend/app/services/discovery_service.py
new file mode 100644
index 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.jsx
index 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.js
index 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.jsx
new file mode 100644
index 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.js
index 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) }); }