Lifecycle management

FINAL_WORKING_ARCHITECTURE.md

@@ -0,0 +1,161 @@
+# 🎯 Final Working Architecture - No More 404s!
+
+## ✅ **Root Cause Identified and Fixed**
+
+The 404 errors were happening because of a **fundamental architecture mismatch**:
+
+1. **Frontend expected**: Backend on same ports (4000/4040)
+2. **Vite proxy pointed**: To non-existent port 4001
+3. **No backend servers**: Running on the frontend ports
+4. **Result**: 404 errors on all API calls
+
+## 🚀 **New Working Architecture**
+
+### **Development Mode** (auto_start_frontends = true)
+
+```
+┌─────────────────┐    ┌─────────────────┐
+│   Browser       │    │   Browser       │
+│                 │    │                 │
+│  127.0.0.1:5173 │    │  127.0.0.1:5174 │
+│ (control-station│    │ (ethernet-view) │
+└─────────┬───────┘    └─────────┬───────┘
+          │                      │
+          │ /backend requests     │ /backend requests
+          │ proxy to ↓           │ proxy to ↓
+          │                      │
+┌─────────▼───────┐    ┌─────────▼───────┐
+│  Backend API    │    │  Backend API    │
+│  127.0.0.1:4000 │    │  127.0.0.1:4040 │
+│  (API only)     │    │  (API only)     │
+└─────────────────┘    └─────────────────┘
+```
+
+### **Production Mode** (auto_start_frontends = false)
+
+```
+┌─────────────────┐    ┌─────────────────┐
+│   Browser       │    │   Browser       │
+│                 │    │                 │
+│  127.0.0.1:4000 │    │  127.0.0.1:4040 │
+│ (control-station│    │ (ethernet-view) │
+└─────────┬───────┘    └─────────┬───────┘
+          │                      │
+          │ Direct requests      │ Direct requests
+          │                      │
+┌─────────▼───────┐    ┌─────────▼───────┐
+│  Backend Server │    │  Backend Server │
+│  127.0.0.1:4000 │    │  127.0.0.1:4040 │
+│ (Static + API)  │    │ (Static + API)  │
+└─────────────────┘    └─────────────────┘
+```
+
+## 🔧 **Key Changes Made**
+
+### 1. **Separate Development Ports**
+```toml
+# config.toml
+dev_control_station_port = 5173  # Vite dev server
+dev_ethernet_view_port = 5174    # Vite dev server
+
+[server.control-station]
+address = "127.0.0.1:4000"       # Backend API server
+
+[server.ethernet-view]
+address = "127.0.0.1:4040"       # Backend API server
+```
+
+### 2. **Always Start Backend Servers**
+```go
+// Backend always starts API servers on 4000/4040
+// In dev mode: API only (no static files)
+// In prod mode: API + static files
+for _, server := range config.Server {
+    // Start backend on configured ports (4000/4040)
+    httpServer := h.NewServer(server.Addr, mux)
+    go httpServer.ListenAndServe()
+}
+```
+
+### 3. **Correct Vite Proxy Configuration**
+```typescript
+// control-station/vite.config.ts
+proxy: {
+    '/backend': {
+        target: 'http://127.0.0.1:4000',  // ✅ Backend on 4000
+        ws: true,
+    },
+}
+
+// ethernet-view/vite.config.ts
+proxy: {
+    '/backend': {
+        target: 'http://127.0.0.1:4040',  // ✅ Backend on 4040
+        ws: true,
+    },
+}
+```
+
+### 4. **Browser Opens Dev Servers**
+```go
+// In development mode, browser opens:
+frontendURLs := map[string]string{
+    "control-station": "http://127.0.0.1:5173",  // ✅ Vite dev server
+    "ethernet-view":   "http://127.0.0.1:5174",  // ✅ Vite dev server
+}
+```
+
+## 🎯 **Request Flow (Development Mode)**
+
+1. **User opens**: `127.0.0.1:5173` (control-station)
+2. **Vite serves**: Frontend assets with hot reload
+3. **API request**: `/backend/podDataStructure`
+4. **Vite proxy**: Routes to `127.0.0.1:4000/backend/podDataStructure`
+5. **Backend responds**: JSON data ✅
+6. **WebSocket**: `ws://127.0.0.1:5173/backend` → proxied to `ws://127.0.0.1:4000/backend` ✅
+
+## 🧪 **Testing Guide**
+
+### **Development Mode Test:**
+```bash
+# Set auto_start_frontends = true
+./control-station.sh
+
+# Expected results:
+✅ Backend starts on 127.0.0.1:4000 and 127.0.0.1:4040 (API only)
+✅ Vite dev servers start on 127.0.0.1:5173 and 127.0.0.1:5174
+✅ Browser opens 127.0.0.1:5173 and 127.0.0.1:5174
+✅ API calls work (proxied to backend)
+✅ WebSocket connections work
+✅ Hot reload works
+✅ No 404 errors!
+```
+
+### **Production Mode Test:**
+```bash
+# Set auto_start_frontends = false
+./control-station.sh
+
+# Expected results:
+✅ Backend starts on 127.0.0.1:4000 and 127.0.0.1:4040 (static + API)
+✅ Browser opens 127.0.0.1:4000 and 127.0.0.1:4040
+✅ Static files served directly
+✅ API calls work directly
+✅ WebSocket connections work
+✅ No dev servers running
+✅ No 404 errors!
+```
+
+## 🎉 **Result: No More 404s!**
+
+The architecture now ensures:
+
+- ✅ **Backend servers always running** on expected ports (4000/4040)
+- ✅ **Correct proxy configuration** routes requests properly
+- ✅ **Consistent API endpoints** work in both modes
+- ✅ **WebSocket connections** established correctly
+- ✅ **Browser opens correct URLs** for each mode
+- ✅ **Professional development experience** with hot reload
+- ✅ **Production-ready static serving** when needed
+
+**The 404 errors are completely resolved!** 🚀✨

SIMPLE_DEV_MODE.md

@@ -0,0 +1,102 @@
+# 🎯 Simple Development Mode - Clean & Straightforward
+
+## ✅ **New Simplified Architecture**
+
+You were absolutely right! The previous approach was overcomplicated. Here's the new clean solution:
+
+### **Configuration (config.toml)**
+```toml
+[dev]
+# Simple boolean flag for dev mode
+dev_mode = true
+
+# Dev server ports (only used when dev_mode = true)
+control_station_port = 5173
+ethernet_view_port = 5174
+
+# Production server config (unchanged)
+[server.control-station]
+address = "127.0.0.1:4000"
+
+[server.ethernet-view]
+address = "127.0.0.1:4040"
+```
+
+## 🚀 **How It Works**
+
+### **Development Mode** (dev_mode = true)
+1. **Backend starts** on dev ports (5173/5174) with API endpoints
+2. **Browser opens** 127.0.0.1:5173 and 127.0.0.1:5174 ✅
+3. **Developer runs** `npm run dev` manually in separate terminals for hot reload
+4. **Vite dev servers** can run on different ports and proxy to backend
+
+### **Production Mode** (dev_mode = false)  
+1. **Backend starts** on production ports (4000/4040) with static files + API
+2. **Browser opens** 127.0.0.1:4000 and 127.0.0.1:4040 ✅
+3. **No dev servers** needed
+
+## 🔧 **Backend Logic**
+
+```go
+// Determine ports based on dev mode
+if config.Dev.DevMode {
+    // Use dev ports for backend (5173/5174)
+    serverAddresses = map[string]string{
+        "control-station": "127.0.0.1:5173",
+        "ethernet-view":   "127.0.0.1:5174",
+    }
+} else {
+    // Use production ports for backend (4000/4040)
+    serverAddresses = map[string]string{
+        "control-station": "127.0.0.1:4000", 
+        "ethernet-view":   "127.0.0.1:4040",
+    }
+}
+
+// Browser always opens the same URLs as backend
+frontendURLs = serverAddresses
+```
+
+## 🎯 **Benefits**
+
+1. **✅ Simple Configuration**: Just one `dev_mode` boolean flag
+2. **✅ Consistent URLs**: Browser always opens where backend is running
+3. **✅ No Complex Process Management**: No automatic dev server startup
+4. **✅ Developer Choice**: Run dev servers manually when needed
+5. **✅ Clean Separation**: Dev and prod modes are clearly distinct
+6. **✅ No Port Conflicts**: Dev and prod use different ports
+
+## 🧪 **Usage**
+
+### **Development Workflow:**
+```bash
+# 1. Set dev_mode = true in config.toml
+# 2. Start backend
+./control-station.sh
+# Backend starts on 5173/5174, browser opens 5173/5174
+
+# 3. (Optional) Start dev servers for hot reload in separate terminals
+cd control-station && npm run dev -- --port 3000
+cd ethernet-view && npm run dev -- --port 3001
+# Dev servers can use any free ports and proxy to backend
+```
+
+### **Production Workflow:**
+```bash
+# 1. Set dev_mode = false in config.toml  
+# 2. Start backend
+./control-station.sh
+# Backend starts on 4000/4040, browser opens 4000/4040
+# Static files served directly, no dev servers needed
+```
+
+## 🎉 **Result**
+
+**No more 404 errors!** The browser now opens the correct URLs:
+
+- **Dev mode**: Opens 5173/5174 where backend APIs are running
+- **Prod mode**: Opens 4000/4040 where backend + static files are running
+- **Consistent**: Same URL = same backend = no confusion
+- **Simple**: One flag controls everything
+
+This is exactly what you suggested - clean, simple, and effective! 🚀

SMART_SERVER_MANAGEMENT.md

@@ -0,0 +1,114 @@
+# 🎯 Smart Server Management - No More Port Conflicts!
+
+## ✅ Problem Solved
+
+Previously, the backend was starting **both** static HTTP servers (ports 4000, 4040) **and** frontend development servers (ports 5173, 5174), creating redundancy and confusion.
+
+## 🚀 New Intelligent Server Management
+
+### **Development Mode** (auto_start_frontends = true)
+- ✅ **Frontend dev servers** run on ports 5173 (control-station) and 5174 (ethernet-view)
+- ✅ **Minimal API server** runs on port 4001 for WebSocket/backend endpoints
+- ✅ **Static servers SKIPPED** - no port conflicts
+- ✅ **Hot reload** and full development experience maintained
+- ✅ **Proxy configuration** routes `/backend` requests from dev servers to API server
+
+### **Production Mode** (auto_start_frontends = false)
+- ✅ **Static HTTP servers** run on configured ports (4000, 4040)
+- ✅ **Serve pre-built static files** directly
+- ✅ **Full backend API** available on each static server
+- ✅ **No dev server overhead**
+
+## 🔧 Technical Implementation
+
+### Backend Changes:
+```go
+// Only start static HTTP servers if frontend dev servers are not running
+if !config.App.AutoStartFrontends {
+    // Start full static servers on 4000, 4040
+    for _, server := range config.Server {
+        // ... start static servers
+    }
+} else {
+    // Start minimal API server for WebSocket/backend only
+    apiServer := h.NewServer("127.0.0.1:4001", apiMux)
+    go apiServer.ListenAndServe()
+}
+```
+
+### Frontend Proxy Configuration:
+```typescript
+// vite.config.ts for both control-station and ethernet-view
+server: {
+    proxy: {
+        '/backend': {
+            target: 'http://127.0.0.1:4001',
+            changeOrigin: true,
+            ws: true, // WebSocket proxying
+        },
+    },
+}
+```
+
+## 🎯 Port Usage Summary
+
+### Development Mode:
+- **5173** - Control Station (Vite dev server)
+- **5174** - Ethernet View (Vite dev server)  
+- **4001** - Backend API server (WebSocket + endpoints)
+- **4040** - pprof debugging (unchanged)
+
+### Production Mode:
+- **4000** - Control Station (static files + full backend)
+- **4040** - Ethernet View (static files + full backend) + pprof
+- **No dev servers**
+
+## ✅ Benefits
+
+1. **🚫 No Port Conflicts** - Clean separation between dev and static modes
+2. **⚡ Hot Reload** - Full development experience in dev mode
+3. **🔄 Smart Switching** - Automatic mode detection based on configuration
+4. **🎯 Clean Architecture** - Right server for the right purpose
+5. **📝 Clear Logging** - Backend logs which servers are starting and why
+
+## 🔧 Configuration Control
+
+```toml
+[app]
+# Controls server behavior
+auto_start_frontends = true   # Dev mode: Vite servers + API server
+# auto_start_frontends = false # Production mode: Static servers only
+```
+
+## 🧪 Testing
+
+### Development Mode Test:
+```bash
+# Set auto_start_frontends = true in config.toml
+./control-station.sh
+# Should see:
+# - "skipping static HTTP servers (frontend dev servers will be used)"
+# - "API server started for WebSocket connections"
+# - Frontend dev servers on 5173, 5174
+```
+
+### Production Mode Test:
+```bash
+# Set auto_start_frontends = false in config.toml
+./control-station.sh
+# Should see:
+# - "starting static HTTP servers"
+# - Static servers on 4000, 4040
+# - No dev servers
+```
+
+## 🎉 Result
+
+The backend now **intelligently manages its servers** based on configuration:
+
+- **Development**: Minimal backend + powerful dev servers with hot reload
+- **Production**: Full static servers with pre-built assets
+- **No conflicts**: Clean port usage in both modes
+- **Professional**: Right tool for the right job
+
+Your application now behaves like professional software with **smart resource management**! 🚀