Enhance deployment system with retry functionality and improved UX

Major Improvements:
- Added retry deployment buttons in machine list for failed deployments
- Added retry button in SSH console modal footer for enhanced UX
- Enhanced deployment process with comprehensive cleanup of existing services
- Improved binary installation with password-based sudo authentication
- Updated configuration generation to include all required sections (agent, ai, network, security)
- Fixed deployment verification and error handling

Security Enhancements:
- Enhanced verifiedStopExistingServices with thorough cleanup process
- Improved binary copying with proper sudo authentication
- Added comprehensive configuration validation

UX Improvements:
- Users can retry deployments without re-running machine discovery
- Retry buttons available from both machine list and console modal
- Real-time deployment progress with detailed console output
- Clear error states with actionable retry options

Technical Changes:
- Modified ServiceDeployment.tsx with retry button components
- Enhanced api/setup_manager.go with improved deployment functions
- Updated main.go with command line argument support (--config, --setup)
- Added comprehensive zero-trust security validation system

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

demo/minimal_agent.go

@@ -0,0 +1,217 @@
+// Demo: Minimal Agent Binary
+// This demonstrates the core architecture without problematic dependencies
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+)
+
+// Minimal types to demonstrate the architecture
+type BinaryType int
+
+const (
+	BinaryTypeAgent BinaryType = iota
+	BinaryTypeHAP
+)
+
+func (bt BinaryType) String() string {
+	switch bt {
+	case BinaryTypeAgent:
+		return "agent"
+	case BinaryTypeHAP:
+		return "hap"
+	default:
+		return "unknown"
+	}
+}
+
+// Minimal runtime config
+type RuntimeConfig struct {
+	BinaryType BinaryType
+	HTTPPort   int
+	HealthPort int
+}
+
+// Minimal services
+type RuntimeServices struct {
+	Config    *Config
+	NodeID    string
+	BinaryType BinaryType
+	HTTPPort   int
+	HealthPort int
+}
+
+type Config struct {
+	Agent struct {
+		ID             string
+		Role           string
+		Specialization string
+		MaxTasks       int
+	}
+}
+
+// Minimal runtime interface
+type Runtime interface {
+	Initialize(ctx context.Context, cfg RuntimeConfig) (*RuntimeServices, error)
+	Start(ctx context.Context, services *RuntimeServices) error
+	Stop(ctx context.Context, services *RuntimeServices) error
+}
+
+// Implementation
+type StandardRuntime struct {
+	services *RuntimeServices
+}
+
+func NewRuntime() Runtime {
+	return &StandardRuntime{}
+}
+
+func (r *StandardRuntime) Initialize(ctx context.Context, cfg RuntimeConfig) (*RuntimeServices, error) {
+	fmt.Printf("🚀 Initializing BZZZ runtime (%s mode)\n", cfg.BinaryType.String())
+	
+	services := &RuntimeServices{
+		Config: &Config{},
+		NodeID: fmt.Sprintf("node-%d", time.Now().Unix()),
+		BinaryType: cfg.BinaryType,
+		HTTPPort: cfg.HTTPPort,
+		HealthPort: cfg.HealthPort,
+	}
+	
+	// Set some demo config
+	services.Config.Agent.ID = fmt.Sprintf("agent-%s-%d", cfg.BinaryType.String(), time.Now().Unix())
+	services.Config.Agent.Role = "demo_role"
+	services.Config.Agent.Specialization = "demo"
+	services.Config.Agent.MaxTasks = 5
+	
+	r.services = services
+	fmt.Println("✅ Runtime initialization completed successfully")
+	return services, nil
+}
+
+func (r *StandardRuntime) Start(ctx context.Context, services *RuntimeServices) error {
+	fmt.Println("🚀 Starting BZZZ runtime services")
+	
+	// Simulate service startup
+	fmt.Printf("🌐 HTTP API server started on :%d\n", services.HTTPPort)
+	fmt.Printf("🏥 Health endpoints available at http://localhost:%d/health\n", services.HealthPort)
+	
+	fmt.Println("✅ All runtime services started successfully")
+	return nil
+}
+
+func (r *StandardRuntime) Stop(ctx context.Context, services *RuntimeServices) error {
+	fmt.Println("🛑 Shutting down BZZZ runtime services")
+	fmt.Println("✅ Graceful shutdown completed")
+	return nil
+}
+
+// Agent-specific runner
+type AgentRunner struct {
+	services *RuntimeServices
+}
+
+func NewAgentRunner(services *RuntimeServices) *AgentRunner {
+	return &AgentRunner{services: services}
+}
+
+func (ar *AgentRunner) Start(ctx context.Context) error {
+	fmt.Println("🤖 Starting autonomous agent runner")
+	fmt.Printf("📍 Node ID: %s\n", ar.services.NodeID)
+	fmt.Printf("🎯 Agent ID: %s\n", ar.services.Config.Agent.ID)
+	fmt.Printf("🎭 Role: %s\n", ar.services.Config.Agent.Role)
+	fmt.Printf("📋 Max Tasks: %d\n", ar.services.Config.Agent.MaxTasks)
+	
+	// Start background processes
+	go ar.announceCapabilities()
+	
+	fmt.Println("✅ Autonomous agent runner started successfully")
+	return nil
+}
+
+func (ar *AgentRunner) announceCapabilities() {
+	ticker := time.NewTicker(30 * time.Second)
+	defer ticker.Stop()
+	
+	for range ticker.C {
+		fmt.Println("📡 Announcing agent capabilities to P2P network")
+	}
+}
+
+func (ar *AgentRunner) Stop(ctx context.Context) error {
+	fmt.Println("🛑 Stopping autonomous agent runner")
+	return nil
+}
+
+func main() {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	fmt.Println("🤖 BZZZ Autonomous Agent (Demo)")
+	fmt.Println("=====================================")
+
+	// Create runtime
+	rt := NewRuntime()
+
+	// Initialize with agent-specific config
+	runtimeConfig := RuntimeConfig{
+		BinaryType: BinaryTypeAgent,
+		HTTPPort:   8080,
+		HealthPort: 8081,
+	}
+
+	// Initialize runtime services
+	services, err := rt.Initialize(ctx, runtimeConfig)
+	if err != nil {
+		log.Fatalf("Failed to initialize runtime: %v", err)
+	}
+
+	// Start shared services
+	if err := rt.Start(ctx, services); err != nil {
+		log.Fatalf("Failed to start runtime: %v", err)
+	}
+
+	// Initialize agent-specific components
+	agentRunner := NewAgentRunner(services)
+	if err := agentRunner.Start(ctx); err != nil {
+		log.Fatalf("Failed to start agent runner: %v", err)
+	}
+
+	fmt.Println("🔍 Autonomous agent listening for task assignments")
+	fmt.Println("📡 Ready for P2P task coordination")
+	fmt.Println("✅ BZZZ autonomous agent system fully operational")
+	
+	// Show architecture separation
+	fmt.Printf("\n📊 Architecture Demo:\n")
+	fmt.Printf("  Binary Type: %s\n", services.BinaryType.String())
+	fmt.Printf("  Shared Runtime: ✅ Initialized\n")
+	fmt.Printf("  Agent Runner: ✅ Started\n")
+	fmt.Printf("  HTTP Port: %d\n", services.HTTPPort)
+	fmt.Printf("  Health Port: %d\n", services.HealthPort)
+	fmt.Printf("  P2P Ready: ✅ (simulated)\n")
+
+	// Wait for shutdown signals
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
+	<-sigChan
+
+	fmt.Println("\n🛑 Shutting down autonomous agent...")
+
+	// Stop agent runner
+	if err := agentRunner.Stop(ctx); err != nil {
+		fmt.Printf("Agent runner shutdown error: %v\n", err)
+	}
+
+	// Stop runtime services
+	if err := rt.Stop(ctx, services); err != nil {
+		fmt.Printf("Runtime shutdown error: %v\n", err)
+	}
+
+	fmt.Println("✅ BZZZ autonomous agent shutdown completed")
+}