feat: first commit

Author: giacomomasseron

.github/copilot-instructions.md

@@ -0,0 +1,86 @@
+# LazyNginx AI Development Guide
+
+## Project Overview
+LazyNginx is a terminal-based Nginx manager built with Go and Bubble Tea (TUI framework). It provides cross-platform menu-driven nginx management without requiring users to remember commands.
+
+## Architecture
+
+### Core Components
+- **main.go**: Entry point that initializes Bubble Tea program with `tea.WithAltScreen()` for full-screen TUI
+- **model.go**: Bubble Tea model implementing Update/View/Init pattern with two display modes:
+  - `mode: "menu"` - Shows interactive menu with cursor navigation
+  - `mode: "output"` - Displays command results (switched via Enter key)
+- **commands.go**: Command execution functions returning `tea.Msg` types for async operations
+- **messages.go**: Custom message types (`statusMsg`, `outputMsg`) for Bubble Tea's Elm architecture
+- **styles.go**: Lipgloss style definitions for consistent terminal UI theming
+
+### Bubble Tea Pattern
+The app uses Bubble Tea's command pattern where:
+1. User selects menu item → `handleSelection()` returns a `tea.Cmd`
+2. Command executes asynchronously → returns a message (`statusMsg` or `outputMsg`)
+3. `Update()` receives message → updates model state
+4. `View()` renders based on current mode
+
+## Platform-Specific Behavior
+
+Commands try multiple approaches in sequence (returns first success):
+
+**Start/Stop/Restart Operations:**
+1. Windows: `net start/stop nginx`
+2. Linux/systemd: `sudo systemctl [action] nginx`
+3. Direct: `sudo nginx [-s stop]`
+
+**Status Check Cascading:**
+1. Windows: `tasklist /FI "IMAGENAME eq nginx.exe"`
+2. systemd: `systemctl is-active nginx`
+3. Unix: `pgrep -x nginx`
+4. Fallback: `ps aux | grep nginx`
+
+**File Discovery:**
+Config/logs checked in order:
+- `/etc/nginx/` (Linux)
+- `C:\nginx\` (Windows)
+- `/usr/local/nginx/` (macOS/Unix)
+
+## Development Patterns
+
+### Adding New Commands
+1. Create function in `commands.go` returning `tea.Msg`:
+   ```go
+   func myCommand() tea.Msg {
+       output, err := exec.Command("mycommand").CombinedOutput()
+       if err != nil {
+           return outputMsg{output: "Error: " + string(output)}
+       }
+       return outputMsg{output: string(output)}
+   }
+   ```
+
+2. Add menu item to `initialModel()` choices slice in [model.go](model.go#L21-L32)
+
+3. Map cursor position to command in `handleSelection()` switch statement in [model.go](model.go#L147-L163)
+
+### Navigation Keys
+- Vim-style (`j`/`k`) and arrow keys handled in [model.go](model.go#L64-L78) Update() switch
+- `q` and `Ctrl+C` handled differently based on `mode` (quit vs return to menu)
+
+### Styling Convention
+All UI styles use Lipgloss with hex color codes defined as package variables in [styles.go](styles.go). Status messages conditionally use `statusStyle` (green) or `errorStyle` (red) based on text content matching in [model.go](model.go#L108-L114).
+
+## Building and Running
+
+```bash
+# Build
+go build -o lazynginx
+
+# Run (requires sudo for service operations on Linux/macOS)
+sudo ./lazynginx
+```
+
+No tests exist. Manual testing requires nginx installed and verifying menu navigation + command execution on target OS.
+
+## Dependencies
+- `github.com/charmbracelet/bubbletea` - TUI framework using Elm architecture
+- `github.com/charmbracelet/lipgloss` - Terminal styling (colors, padding, bold)
+
+Binary output: `lazynginx` (Unix) or `lazynginx.exe` (Windows)

.gitignore

@@ -0,0 +1,32 @@
+# Binaries
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+lazynginx
+lazynginx.exe
+
+# Test binary
+*.test
+
+# Output of the go coverage tool
+*.out
+
+# Dependency directories
+vendor/
+
+# Go workspace file
+go.work
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+

README.md

@@ -0,0 +1,107 @@
+# LazyNginx 🚀
+
+A beautiful terminal-based Nginx manager built with Go and [Bubble Tea](https://github.com/charmbracelet/bubbletea).
+
+## Features
+
+- ✅ Check Nginx status
+- 🚀 Start/Stop/Restart Nginx
+- 🔄 Reload configuration
+- ✅ Test configuration
+- 📄 View configuration file
+- 📊 View error logs
+- 📈 View access logs
+- 🎨 Beautiful terminal UI
+
+## Installation
+
+### Prerequisites
+
+- Go 1.21 or later
+- Nginx installed on your system
+
+### Build from Source
+
+```bash
+git clone <repository-url>
+cd lazynginx
+go mod download
+go build -o lazynginx
+```
+
+### Run
+
+```bash
+./lazynginx
+```
+
+Or on Windows:
+```bash
+lazynginx.exe
+```
+
+## Usage
+
+### Navigation
+
+- `↑` / `↓` or `k` / `j`: Navigate menu
+- `Enter`: Select option
+- `q` or `Ctrl+C`: Quit application
+
+### Available Commands
+
+1. **Check Status** - Check if Nginx is running
+2. **Start Nginx** - Start the Nginx service
+3. **Stop Nginx** - Stop the Nginx service
+4. **Restart Nginx** - Restart the Nginx service
+5. **Reload Configuration** - Reload Nginx configuration without downtime
+6. **Test Configuration** - Test Nginx configuration for syntax errors
+7. **View Configuration** - Display Nginx configuration file
+8. **View Error Logs** - Show last 50 lines of error log
+9. **View Access Logs** - Show last 50 lines of access log
+10. **Quit** - Exit the application
+
+## Platform Support
+
+The application automatically detects your platform and uses the appropriate commands:
+
+- **Linux**: Uses `systemctl` when available, falls back to direct `nginx` commands
+- **Windows**: Uses `net start/stop` commands
+- **macOS/Unix**: Uses direct `nginx` commands
+
+## Permissions
+
+Some operations (start, stop, restart, reload) may require administrator/sudo privileges depending on your system configuration.
+
+### Linux/macOS
+```bash
+sudo ./lazynginx
+```
+
+### Windows
+Run as Administrator
+
+## Configuration
+
+The application automatically searches for Nginx in common locations:
+
+- `/etc/nginx/nginx.conf` (Linux)
+- `C:\nginx\conf\nginx.conf` (Windows)
+- `/usr/local/nginx/conf/nginx.conf` (macOS/Unix)
+
+## Logs
+
+The application looks for logs in:
+
+- `/var/log/nginx/` (Linux)
+- `C:\nginx\logs\` (Windows)
+- `/usr/local/nginx/logs/` (macOS/Unix)
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+

boxlayout/boxlayout.go

@@ -0,0 +1,153 @@
+package boxlayout
+
+// Dimensions represents the coordinates of a box
+type Dimensions struct {
+	X0 int
+	X1 int
+	Y0 int
+	Y1 int
+}
+
+// Direction defines how children are laid out
+type Direction int
+
+const (
+	ROW    Direction = iota // Children stacked vertically
+	COLUMN                  // Children arranged horizontally
+)
+
+// Box represents a layout box that can contain children or a window
+type Box struct {
+	// Direction decides how the children boxes are laid out
+	Direction Direction
+
+	// Children are the sub-boxes
+	Children []*Box
+
+	// Window refers to the name of the window this box represents
+	Window string
+
+	// Size is static size (height for ROW parent, width for COLUMN parent)
+	Size int
+
+	// Weight is dynamic size proportion (after static sizes allocated)
+	Weight int
+}
+
+// ArrangeWindows calculates the dimensions for all windows in the box tree
+func ArrangeWindows(root *Box, x0, y0, width, height int) map[string]Dimensions {
+	children := root.Children
+	if len(children) == 0 {
+		// leaf node
+		if root.Window != "" {
+			dimensionsForWindow := Dimensions{
+				X0: x0,
+				Y0: y0,
+				X1: x0 + width - 1,
+				Y1: y0 + height - 1,
+			}
+			return map[string]Dimensions{root.Window: dimensionsForWindow}
+		}
+		return map[string]Dimensions{}
+	}
+
+	direction := root.Direction
+
+	var availableSize int
+	if direction == COLUMN {
+		availableSize = width
+	} else {
+		availableSize = height
+	}
+
+	sizes := calcSizes(children, availableSize)
+
+	result := map[string]Dimensions{}
+	offset := 0
+	for i, child := range children {
+		boxSize := sizes[i]
+
+		var resultForChild map[string]Dimensions
+		if direction == COLUMN {
+			resultForChild = ArrangeWindows(child, x0+offset, y0, boxSize, height)
+		} else {
+			resultForChild = ArrangeWindows(child, x0, y0+offset, width, boxSize)
+		}
+
+		result = mergeDimensionMaps(result, resultForChild)
+		offset += boxSize
+	}
+
+	return result
+}
+
+// calcSizes determines the size of each box based on static sizes and weights
+func calcSizes(boxes []*Box, availableSpace int) []int {
+	totalWeight := 0
+	reservedSpace := 0
+
+	for _, box := range boxes {
+		if box.isStatic() {
+			reservedSpace += box.Size
+		} else {
+			totalWeight += box.Weight
+		}
+	}
+
+	dynamicSpace := max(0, availableSpace-reservedSpace)
+
+	unitSize := 0
+	extraSpace := 0
+	if totalWeight > 0 {
+		unitSize = dynamicSpace / totalWeight
+		extraSpace = dynamicSpace % totalWeight
+	}
+
+	result := make([]int, len(boxes))
+	for i, box := range boxes {
+		if box.isStatic() {
+			result[i] = min(availableSpace, box.Size)
+		} else {
+			result[i] = unitSize * box.Weight
+		}
+	}
+
+	// Distribute remainder across dynamic boxes
+	for i := 0; i < len(boxes) && extraSpace > 0; i++ {
+		if !boxes[i].isStatic() {
+			result[i]++
+			extraSpace--
+		}
+	}
+
+	return result
+}
+
+func (b *Box) isStatic() bool {
+	return b.Size > 0
+}
+
+func mergeDimensionMaps(a map[string]Dimensions, b map[string]Dimensions) map[string]Dimensions {
+	result := map[string]Dimensions{}
+	for k, v := range a {
+		result[k] = v
+	}
+	for k, v := range b {
+		result[k] = v
+	}
+	return result
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}