ci: adapt workflow for Forgejo Actions (replace gh-release with API call)

Added arm64 build
Initialize Go module
2026-02-07 17:48:19 +01:00 · 2025-12-15 16:26:57 +01:00 · 2025-09-05 13:49:48 +02:00
10 changed files with 2091 additions and 764 deletions
--- a/.env
+++ b/.env
@ -1,4 +0,0 @@
-SERVER_NAME=delemaco
-SERVER_USER=root
-MAC_ADDRESS=b8:cb:29:a1:f3:88
-PORT=8080
--- a/.env.sample
+++ b/.env.sample
@ -2,3 +2,4 @@ SERVER_NAME=pippo
 SERVER_USER=root
 MAC_ADDRESS=aa:aa:aa:aa:aa:aa
 PORT=8080
+SHUTDOWN_PASSWORD="password"
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@ -2,119 +2,137 @@ name: Build and Release

 on:
  push:
-    branches: [ main ]
+    branches: [main]
  pull_request:
-    branches: [ main ]
+    branches: [main]

 jobs:
  build:
-    name: Cross-compile for Raspberry Pi
+    name: Build multi-arch Raspberry Pi binaries
    runs-on: ubuntu-latest

    steps:
-    - name: Checkout code
-      uses: actions/checkout@v3
+      - name: Checkout code
+        uses: actions/checkout@v4

-    - name: Set up Go
-      uses: actions/setup-go@v4
-      with:
-        go-version: '1.20'
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.22"

-    - name: Build for ARM (Pi Zero, Pi 1 - ARMv6)
-      run: |
-        GOOS=linux GOARCH=arm GOARM=6 go build -ldflags="-s -w" -o wol-server-arm6
+      - name: Build for ARMv6 (Pi Zero / Pi 1)
+        run: |
+          GOOS=linux GOARCH=arm GOARM=6 \
+          go build -ldflags="-s -w" -o wol-server-armv6

-    - name: Create systemd service file
-      run: |
-        cat > wol-server.service << 'EOL'
-        [Unit]
-        Description=WOL Server Go Application
-        After=network.target
+      - name: Build for ARM64 (Pi Zero 2 / Pi 3 / Pi 4 / Pi 5)
+        run: |
+          GOOS=linux GOARCH=arm64 \
+          go build -ldflags="-s -w" -o wol-server-arm64

-        [Service]
-        User=pi
-        WorkingDirectory=/home/pi/wol-server
-        ExecStart=/home/pi/wol-server/wol-server
-        Restart=always
+      - name: Create systemd service file
+        run: |
+          cat > wol-server.service << 'EOF'
+          [Unit]
+          Description=WOL Server Go Application
+          After=network.target

-        [Install]
-        WantedBy=multi-user.target
-        EOL
+          [Service]
+          Type=simple
+          User=loke
+          WorkingDirectory=/home/loke/wol-server
+          ExecStart=/home/loke/wol-server/wol-server
+          Restart=always
+          RestartSec=3

-    - name: Create deployment script
-      run: |
-        cat > deploy.sh << 'EOL'
-        #!/bin/bash
+          [Install]
+          WantedBy=multi-user.target
+          EOF

-        # Detect Raspberry Pi model and use the appropriate binary
-        MODEL=$(cat /proc/cpuinfo | grep "Model" | sed 's/Model\s*:\s*//g')
-        echo "Detected model: $MODEL"
+      - name: Create install script
+        run: |
+          cat > install.sh << 'EOF'
+          #!/bin/bash
+          set -e

-        # Select the right binary based on processor architecture
-        ARCH=$(uname -m)
-        echo "Architecture: $ARCH"
+          INSTALL_DIR="$HOME/wol-server"

-        if [[ "$ARCH" == "aarch64" ]]; then
-            echo "Using ARM64 binary"
-            cp wol-server-arm64 wol-server
-        elif [[ "$ARCH" == "armv7l" ]]; then
-            echo "Using ARMv7 binary"
-            cp wol-server-arm7 wol-server
-        else
-            echo "Using ARMv6 binary"
-            cp wol-server-arm6 wol-server
-        fi
+          echo "Creating installation directory..."
+          mkdir -p "$INSTALL_DIR/templates"

-        echo "Creating directory..."
-        mkdir -p ~/wol-server
+          ARCH=$(uname -m)
+          case "$ARCH" in
+            armv6l|armv7l)
+              BIN="wol-server-armv6"
+              ;;
+            aarch64)
+              BIN="wol-server-arm64"
+              ;;
+            *)
+              echo "Unsupported architecture: $ARCH"
+              exit 1
+              ;;
+          esac

-        echo "Copying application..."
-        cp wol-server ~/wol-server/
-        chmod +x ~/wol-server/wol-server
+          echo "Detected architecture: $ARCH"
+          echo "Using binary: $BIN"

-        echo "Installing service..."
-        sudo cp wol-server.service /etc/systemd/system/
-        sudo systemctl daemon-reload
-        sudo systemctl enable wol-server
-        sudo systemctl restart wol-server
+          cp "$BIN" "$INSTALL_DIR/wol-server"
+          chmod +x "$INSTALL_DIR/wol-server"

-        echo "Deployment complete!"
-        echo "Service status:"
-        sudo systemctl status wol-server
-        EOL
+          echo "Installing templates..."
+          cp -r templates/* "$INSTALL_DIR/templates/"

-        chmod +x deploy.sh
+          echo "Installing systemd service..."
+          sudo cp wol-server.service /etc/systemd/system/
+          sudo systemctl daemon-reload
+          sudo systemctl enable wol-server

-    - name: Create archive for each platform
-      run: |
-        # ARMv6 package
-        mkdir -p armv6-package
-        cp wol-server-arm6 armv6-package/wol-server-arm6
-        cp wol-server.service armv6-package/
-        cp deploy.sh armv6-package/
-        tar -czf wol-server-armv6.tar.gz -C armv6-package .
+          echo "Installing dependencies..."
+          sudo apt-get update -qq
+          sudo apt-get install -y wakeonlan sshpass

-        # All-in-one package
-        mkdir -p all-package
-        cp wol-server-arm6 all-package/
-        cp wol-server.service all-package/
-        cp deploy.sh all-package/
-        tar -czf wol-server-all.tar.gz -C all-package .
+          echo "Starting service..."
+          sudo systemctl restart wol-server

-    - name: Create Release
-      id: create_release
-      uses: softprops/action-gh-release@v1
-      if: github.ref == 'refs/heads/main'
-      with:
-        tag_name: v${{ github.run_number }}
-        name: Release v${{ github.run_number }}
-        draft: false
-        prerelease: false
-        files: |
-          wol-server-arm6
-          wol-server.service
-          deploy.sh
-          wol-server-armv6.tar.gz
-          wol-server-all.tar.gz
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          echo "==========================================="
+          echo "WOL Server installed successfully!"
+          echo "URL: http://$(hostname -I | awk '{print $1}'):8080"
+          echo "==========================================="
+          EOF
+
+          chmod +x install.sh
+
+      - name: Create release package
+        run: |
+          mkdir -p package
+          cp wol-server-armv6 package/
+          cp wol-server-arm64 package/
+          cp wol-server.service package/
+          cp install.sh package/
+          cp -r templates package/
+
+          tar -czf wol-server.tar.gz -C package .
+
+      - name: Create Forgejo Release
+        if: github.ref == 'refs/heads/main'
+        run: |
+          TAG="v${{ github.run_number }}"
+          API_URL="${{ github.server_url }}/api/v1"
+          REPO="${{ github.repository }}"
+
+          # Create release
+          RELEASE_ID=$(curl -s -X POST \
+            -H "Authorization: token ${{ secrets.GITEA_TOKEN }}" \
+            -H "Content-Type: application/json" \
+            "${API_URL}/repos/${REPO}/releases" \
+            -d "{\"tag_name\": \"${TAG}\", \"name\": \"Release ${TAG}\", \"draft\": false, \"prerelease\": false}" \
+            | grep -o '"id":[0-9]*' | head -1 | cut -d: -f2)
+
+          # Upload asset
+          curl -s -X POST \
+            -H "Authorization: token ${{ secrets.GITEA_TOKEN }}" \
+            "${API_URL}/repos/${REPO}/releases/${RELEASE_ID}/assets?name=wol-server.tar.gz" \
+            -F "attachment=@wol-server.tar.gz" > /dev/null
+
+          echo "Release ${TAG} created with asset wol-server.tar.gz"
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1 @@
+.env
--- a/README.md
+++ b/README.md
@ -1,293 +1,286 @@
-# WOL-Server
+# WOL Server - Wake-on-LAN Control Panel for Raspberry Pi

-A lightweight Wake-on-LAN (WOL) server application designed specifically for Raspberry Pi devices. This tool allows you to remotely power on your network devices using magic packets through a simple, user-friendly interface.
+A lightweight web-based Wake-on-LAN control panel designed for Raspberry Pi that lets you remotely power on and shut down your network devices.
+
+![WOL Server Screenshot](https://i.imgur.com/example.jpg)

 ## Features

- **Cross-Platform Compatibility**: Optimized for various Raspberry Pi models (Zero, 1, 2, 3, 4)
- **Easy Installation**: Automated deployment script for quick setup
- **Systemd Integration**: Runs as a system service for reliability
- **Simple Web Interface**: Control your devices through an intuitive web UI
- **Configurable**: Easily customize settings through environment variables or `.env` file
- **Low Resource Usage**: Minimal footprint to run efficiently on any Pi
+- **Simple Web Interface**: Boot and shut down your server with a clean, responsive UI
+- **Status Monitoring**: Check if your target device is online with auto-refreshing UI
+- **Scheduled Backup Window**: Configure automatic daily, bi-daily, weekly, or monthly server startup and shutdown for backup operations
+- **Auto Shutdown**: Shut down the server automatically at the end of the backup window
+- **Smart Shutdown Protection**: Only auto-shuts down servers that were started by the scheduler
+- **Passwordless Operation**: Uses environment variable for all shutdown operations
+- **Multiple Shutdown Methods**: Supports various SSH authentication methods for reliable automatic shutdown
+- **Raspberry Pi Optimized**: Built specifically for ARM processors found in all Raspberry Pi models
+- **Secure Shutdown**: Password-protected shutdown functionality
+- **Lightweight**: Minimal resource usage ideal for running on even the oldest Pi models
+- **Easy Setup**: Simple installation process with clear instructions

 ## Installation

-### Method 1: Pre-built Release (Recommended)
+### Prerequisites

-1. **Check which binary is right for your Raspberry Pi model**:
+- Raspberry Pi (any model) running Raspberry Pi OS
+- Network connection
+- Basic knowledge of SSH/terminal
+
+### Option 1: One-Command Installation
+
+1. **Download the latest release** on your local machine from the [Releases page](https://github.com/thisloke/wol-server/releases)
+
+2. **Transfer the package to your Raspberry Pi** using SCP:
   ```bash
-   uname -m
-   ```
-   - `armv6l`: Use `wol-server-arm6` (Pi Zero, Pi 1)
-   - `armv7l`: Use `wol-server-arm7` (Pi 2, Pi 3 32-bit)
-   - `aarch64`: Use `wol-server-arm64` (Pi 3/4 64-bit)
-
-2. **Download the latest release**:
-
-   Navigate to [Releases](https://github.com/thisloke/wol-server/releases) and download the appropriate files for your Pi, or use the following commands:
-
-   ```bash
-   # Create a directory for installation
-   mkdir -p ~/wol-install
-   cd ~/wol-install
-
-   # Download the executable (replace v6 with the latest version number)
-   wget https://github.com/thisloke/wol-server/releases/download/v6/wol-server-arm6
-
-   # Download the service file
-   wget https://github.com/thisloke/wol-server/releases/download/v6/wol-server.service
-
-   # Download the deploy script
-   wget https://github.com/thisloke/wol-server/releases/download/v6/deploy.sh
-
-   # Make files executable
-   chmod +x wol-server-arm6
-   chmod +x deploy.sh
+   scp wol-server.tar.gz pi@your-pi-ip:~/
   ```

-3. **Create a `.env` file for configuration**:
+3. **SSH into your Raspberry Pi**:
   ```bash
-   cat > .env << EOL
-   # Server Configuration
+   ssh pi@your-pi-ip
+   ```
+
+4. **Install with a single command**:
+   ```bash
+   tar -xzf wol-server.tar.gz && ./install.sh
+   ```
+
+5. **Access the web interface** at:
+   ```
+   http://your-pi-ip:8080
+   ```
+
+### Option 2: Manual Installation
+
+If you prefer a manual approach or encounter issues with the automated install:
+
+1. **Create installation directory**:
+   ```bash
+   mkdir -p ~/wol-server/templates
+   ```
+
+2. **Transfer and install program files**:
+   ```bash
+   # Copy the executable
+   cp wol-server-arm6 ~/wol-server/wol-server
+   chmod +x ~/wol-server/wol-server
+
+   # Copy template files
+   cp templates/* ~/wol-server/templates/
+
+   # Create .env file
+   cat > ~/wol-server/.env << EOL
   SERVER_NAME=pippo
   SERVER_USER=root
-   MAC_ADDRESS=aa:aa:aa:aa:aa:aa
+   MAC_ADDRESS=aa:bb:cc:dd:ee:ff
   PORT=8080
   EOL
   ```

-4. **Run the deployment script**:
+3. **Install service**:
   ```bash
-   ./deploy.sh
+   sudo cp wol-server.service /etc/systemd/system/
+   sudo systemctl daemon-reload
+   sudo systemctl enable wol-server
+   sudo systemctl start wol-server
   ```

-### Method 2: Build from Source
-
-If you prefer to build the application from source:
-
-```bash
-# Install Go (if not already installed)
-sudo apt update
-sudo apt install golang-go
-
-# Clone the repository
-git clone https://github.com/thisloke/wol-server.git
-cd wol-server
-
-# Install dependencies
-go get github.com/joho/godotenv
-
-# Create a .env file for configuration
-cat > .env << EOL
-# Server Configuration
-SERVER_NAME=pippo
-SERVER_USER=root
-MAC_ADDRESS=aa:aa:aa:aa:aa:aa
-PORT=8080
-EOL
-
-# Build the application
-go build -o wol-server
-
-# Create installation directory
-mkdir -p ~/wol-server
-
-# Copy the binary and config
-cp wol-server ~/wol-server/
-cp .env ~/wol-server/
-chmod +x ~/wol-server/wol-server
-
-# Create and install systemd service
-sudo bash -c 'cat > /etc/systemd/system/wol-server.service << EOL
-[Unit]
-Description=WOL Server Go Application
-After=network.target
-
-[Service]
-User=pi
-WorkingDirectory=/home/pi/wol-server
-ExecStart=/home/pi/wol-server/wol-server
-Restart=always
-
-[Install]
-WantedBy=multi-user.target
-EOL'
-
-# Enable and start the service
-sudo systemctl daemon-reload
-sudo systemctl enable wol-server
-sudo systemctl start wol-server
-```
-
-### Method 3: Manual Installation
-
-If you encounter issues with the deployment script:
-
-```bash
-# Create the application directory
-mkdir -p ~/wol-server
-
-# Copy the binary and rename it
-cp wol-server-arm6 ~/wol-server/wol-server
-chmod +x ~/wol-server/wol-server
-
-# Copy the .env file
-cp .env ~/wol-server/
-
-# Install the service file
-sudo cp wol-server.service /etc/systemd/system/
-sudo systemctl daemon-reload
-sudo systemctl enable wol-server
-sudo systemctl start wol-server
-```
+4. **Install required dependencies**:
+   ```bash
+   sudo apt-get update
+   sudo apt-get install -y wakeonlan sshpass
+   ```

 ## Configuration

-WOL-server can be configured using environment variables or a `.env` file in the application directory.
+The application can be configured by editing the `.env` file in the installation directory:
+
+```bash
+nano ~/wol-server/.env
+```

 ### Available Configuration Options

-| Environment Variable | Description | Default Value |
-|----------------------|-------------|---------------|
-| `SERVER_NAME` | Name of the server to ping/wake | `pippo` |
-| `SERVER_USER` | SSH username for remote commands | `root` |
-| `MAC_ADDRESS` | MAC address of the target server | `aa:aa:aa:aa:aa:aa` |
-| `PORT` | The port number for the web server | `8080` |
+| Setting | Description | Default |
+|---------|-------------|---------|
+| `SERVER_NAME` | Hostname/IP of target server | pippo |
+| `SERVER_USER` | SSH username for shutdown | root |
+| `MAC_ADDRESS` | MAC address for Wake-on-LAN | aa:bb:cc:dd:ee:ff |
+| `PORT` | Web interface port | 8080 |
+| `SHUTDOWN_PASSWORD` | Password for all shutdown operations | None |
+| `REFRESH_INTERVAL` | UI refresh interval in seconds | 60 |

-### Customizing Your Configuration
-
-You can edit the `.env` file to modify the application's behavior:
-
-```bash
-# Navigate to the installation directory
-cd ~/wol-server
-
-# Edit the .env file
-nano .env
-```
-
-After modifying the configuration, restart the service:
+The scheduled backup window configuration is stored in `schedule.json` in the installation directory. It includes the start time, end time, and frequency settings.

+After changing configuration, restart the service:
 ```bash
 sudo systemctl restart wol-server
 ```

 ## Usage

-Once installed, the WOL server will be accessible at:
+### Accessing the Interface
+
+Open a web browser and navigate to:
 ```
 http://your-pi-ip:8080
 ```
-(or whatever port you've configured)

-### Using the Web Interface
+### Features

-1. **Wake Server**: Click the "Boot" button to send a Wake-on-LAN magic packet to the configured MAC address
-2. **Shut Down Server**: Click the "Shutdown" button, confirm, and enter your password if required
+- **Status Checking**: The interface shows the current status (Online/Offline)
+- **Booting**: Click the "Boot" button to send a WOL magic packet
+- **Shutting Down**: Click "Shutdown" and enter your SSH password when prompted
+- **Scheduled Backup Window**: Configure automatic server startup and shutdown on a regular schedule

-## Service Management
+#### Using Scheduled Backup Window

-Control the WOL server using standard systemd commands:
+1. Click "Configure Schedule" in the Scheduled Backup Window section
+2. Enter your desired start and end times (in 24-hour format)
+3. Select a frequency (daily, every 2 days, weekly, or monthly)
+4. Optionally, enable "Auto Shutdown" (requires SHUTDOWN_PASSWORD in .env file)
+5. Click "Save Schedule" to activate
+6. The server will automatically boot at the start time and:
+   - If auto shutdown is enabled: automatically shut down at the end time
+   - If auto shutdown is disabled: remain on until manually shut down
+7. To modify an existing schedule, click "Edit Schedule"
+8. To disable, click "Disable Schedule" from the main interface
+
+**Note:** All shutdown operations (manual and scheduled) use the SHUTDOWN_PASSWORD from your .env file.
+
+#### Auto Shutdown Feature
+
+The auto shutdown feature provides several advantages:
+- Saves power by ensuring the server only runs during scheduled backup periods
+- Prevents the server from accidentally remaining on after backups are complete
+- Fully automates the backup window process
+- Smart protection: only shuts down servers that were started by the scheduler
+
+**Requirements for Shutdown Operations:**
+1. Set the `SHUTDOWN_PASSWORD` in your .env file
+2. The SSH server must be properly configured on the target server
+3. The user account specified in the configuration must have sudo privileges
+4. The password must be correct for the specified user account
+5. The server must allow password authentication via SSH
+
+**Troubleshooting Shutdown Operations:**
+- If shutdown fails, check the logs for specific error messages
+- Ensure `sshpass` is installed on your Raspberry Pi (`sudo apt-get install sshpass`)
+- Verify you can manually SSH to the server with the provided credentials
+- Confirm the user has sudo privileges to run the shutdown command
+- Check if the server requires SSH key authentication instead of password
+- Verify the SHUTDOWN_PASSWORD is correctly set in your .env file
+
+#### Auto-Refreshing UI
+
+The web interface automatically refreshes every minute (or according to the REFRESH_INTERVAL setting) to show the current server status. This ensures you always see up-to-date information without having to manually refresh the page.
+
+## Maintenance
+
+### Checking Service Status

 ```bash
-# Check service status
 sudo systemctl status wol-server
-
-# Stop the service
-sudo systemctl stop wol-server
-
-# Start the service
-sudo systemctl start wol-server
-
-# Restart the service
-sudo systemctl restart wol-server
-
-# View logs
-journalctl -u wol-server -f
 ```

-## Updating to a New Version
-
-To update to a new version:
+### Viewing Logs

 ```bash
-# Navigate to a temporary directory
-mkdir -p ~/wol-update
-cd ~/wol-update
-
-# Download the latest release (replace v7 with the latest version number)
-wget https://github.com/thisloke/wol-server/releases/download/v7/wol-server-arm6
-chmod +x wol-server-arm6
-
-# Stop the service
-sudo systemctl stop wol-server
-
-# Replace the binary
-cp wol-server-arm6 ~/wol-server/wol-server
-
-# Start the service
-sudo systemctl start wol-server
-
-# Clean up
-cd ~
-rm -rf ~/wol-update
+sudo journalctl -u wol-server -f
 ```

+### Updating
+
+To update to a newer version:
+
+1. Download and transfer the latest release
+2. Stop the service:
+   ```bash
+   sudo systemctl stop wol-server
+   ```
+3. Extract the new files:
+   ```bash
+   tar -xzf wol-server.tar.gz
+   ```
+4. Run the install script:
+   ```bash
+   ./install.sh
+   ```
+
 ## Troubleshooting

-### Checking Your Raspberry Pi Architecture
-
-If you need to verify which version of the application you should use:
+### Service Won't Start

+Check for template errors:
 ```bash
-uname -m
+ls -la ~/wol-server/templates/
 ```

-This will output your Pi's architecture:
- `armv6l`: Use the `wol-server-arm6` binary (Pi Zero, Pi 1)
- `armv7l`: Use the `wol-server-arm7` binary (Pi 2, Pi 3)
- `aarch64`: Use the `wol-server-arm64` binary (64-bit Pi 3, Pi 4)
-
-### Service Not Starting
-
-If the service doesn't start properly, check the logs:
-
+Verify the .env file exists:
 ```bash
-journalctl -u wol-server -e
+cat ~/wol-server/.env
 ```

-### Checking Configuration
+### Boot Command Not Working

-Verify that your configuration is being properly loaded:
+1. Ensure `wakeonlan` is installed:
+   ```bash
+   which wakeonlan || sudo apt-get install wakeonlan
+   ```
+2. Verify the MAC address is correct in your .env file
+3. Make sure the target device is properly configured for Wake-on-LAN

+### Shutdown Not Working
+
+1. Verify `sshpass` is installed:
+   ```bash
+   which sshpass || sudo apt-get install sshpass
+   ```
+2. Check that the SERVER_USER setting in .env is correct
+3. Ensure SSH access is working between your Pi and the target server
+
+## Advanced Configuration
+
+### Running on a Different Port
+
+Edit the `.env` file:
 ```bash
-# View the environment variables being used
-sudo systemctl status wol-server
+echo "PORT=8181" >> ~/wol-server/.env
 ```

-Look for a line in the output that shows the loaded configuration values.
-
-### Permission Issues
-
-Make sure the binary has execute permissions:
+### Multiple Target Machines

+To control multiple devices, you can install multiple instances:
 ```bash
-chmod +x ~/wol-server/wol-server
+# Create a second instance
+mkdir -p ~/wol-server2/templates
+cp -r ~/wol-server/templates/* ~/wol-server2/templates/
+cp ~/wol-server/wol-server ~/wol-server2/
+
+# Different config
+cat > ~/wol-server2/.env << EOL
+SERVER_NAME=server2
+SERVER_USER=admin
+MAC_ADDRESS=aa:bb:cc:dd:ee:ff
+PORT=8081
+EOL
+
+# Create a new service
+sudo cp /etc/systemd/system/wol-server.service /etc/systemd/system/wol-server2.service
+sudo sed -i 's|/home/pi/wol-server|/home/pi/wol-server2|g' /etc/systemd/system/wol-server2.service
+sudo systemctl daemon-reload
+sudo systemctl enable wol-server2
+sudo systemctl start wol-server2
 ```

-### Can't Download Release Files
+## Project Information

-If you're having trouble downloading the release files directly, you can also:
+Designed for use with Raspberry Pi to provide a simple way to manage servers and devices on your local network. The web interface makes it easy to power on and off machines without having to remember MAC addresses or commands.

-1. Download the files on your computer
-2. Transfer them to your Raspberry Pi using SCP, SFTP, or a USB drive
-3. Continue with the installation steps as described above
+### Contributing

-## Contributing
+Contributions are welcome! Feel free to submit pull requests or open issues to help improve this project.

-Contributions are welcome! Feel free to submit pull requests or open issues for bugs and feature requests.
-
-## License
+### License

 This project is licensed under the MIT License - see the LICENSE file for details.
--- a/handlers.go
+++ b/handlers.go
@ -4,6 +4,7 @@ import (
 	"log"
 	"net/http"
 	"runtime"
+	"time"
 )

 // Handle the root route - show status
@ -13,21 +14,32 @@ func indexHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}

+	// Add cache control headers to prevent caching
+	w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+	w.Header().Set("Pragma", "no-cache")
+	w.Header().Set("Expires", "0")
+
 	online := isServerOnline()
 	status := "Online"
-	color := "#4caf50"  // Material green
+	color := "#4caf50" // Material green
 	if !online {
 		status = "Offline"
-		color = "#d32f2f"  // Material red
+		color = "#d32f2f" // Material red
 	}

+	// Get current schedule configuration
+	scheduleConfig := GetScheduleConfig()
+
 	data := StatusData{
-		Server:       serverName,
-		Status:       status,
-		Color:        color,
-		IsTestMode:   runtime.GOOS == "darwin",
-		AskPassword:  false,
-		ErrorMessage: "",
+		Server:          serverName,
+		Status:          status,
+		Color:           color,
+		IsTestMode:      runtime.GOOS == "darwin",
+		AskPassword:     false,
+		ErrorMessage:    "",
+		Schedule:        scheduleConfig,
+		LastUpdated:     time.Now().Format("2006-01-02 15:04:05"),
+		RefreshInterval: refreshInterval,
 	}

 	if err := tmpl.Execute(w, data); err != nil {
@ -47,11 +59,14 @@ func bootHandler(w http.ResponseWriter, r *http.Request) {

 		// Display booting status
 		data := StatusData{
-			Server:      serverName,
-			Status:      "Booting",
-			Color:       "#607d8b",  // Material blue-gray
-			IsTestMode:  runtime.GOOS == "darwin",
-			AskPassword: false,
+			Server:          serverName,
+			Status:          "Booting",
+			Color:           "#607d8b", // Material blue-gray
+			IsTestMode:      runtime.GOOS == "darwin",
+			AskPassword:     false,
+			Schedule:        GetScheduleConfig(),
+			LastUpdated:     time.Now().Format("2006-01-02 15:04:05"),
+			RefreshInterval: refreshInterval,
 		}
 		if err := tmpl.Execute(w, data); err != nil {
 			http.Error(w, "Failed to render template", http.StatusInternalServerError)
@ -60,11 +75,14 @@ func bootHandler(w http.ResponseWriter, r *http.Request) {
 	} else {
 		// Server is already online
 		data := StatusData{
-			Server:      serverName,
-			Status:      "Online",
-			Color:       "#4caf50",  // Material green
-			IsTestMode:  runtime.GOOS == "darwin",
-			AskPassword: false,
+			Server:          serverName,
+			Status:          "Online",
+			Color:           "#4caf50", // Material green
+			IsTestMode:      runtime.GOOS == "darwin",
+			AskPassword:     false,
+			Schedule:        GetScheduleConfig(),
+			LastUpdated:     time.Now().Format("2006-01-02 15:04:05"),
+			RefreshInterval: refreshInterval,
 		}
 		if err := tmpl.Execute(w, data); err != nil {
 			http.Error(w, "Failed to render template", http.StatusInternalServerError)
@ -80,11 +98,14 @@ func confirmShutdownHandler(w http.ResponseWriter, r *http.Request) {
 	if !online {
 		// Server is already offline
 		data := StatusData{
-			Server:      serverName,
-			Status:      "Offline",
-			Color:       "#d32f2f",  // Material red
-			IsTestMode:  runtime.GOOS == "darwin",
-			AskPassword: false,
+			Server:          serverName,
+			Status:          "Offline",
+			Color:           "#d32f2f", // Material red
+			IsTestMode:      runtime.GOOS == "darwin",
+			AskPassword:     false,
+			Schedule:        GetScheduleConfig(),
+			LastUpdated:     time.Now().Format("2006-01-02 15:04:05"),
+			RefreshInterval: refreshInterval,
 		}
 		if err := tmpl.Execute(w, data); err != nil {
 			http.Error(w, "Failed to render template", http.StatusInternalServerError)
@ -93,43 +114,54 @@ func confirmShutdownHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}

-	// Show confirmation dialog
-	data := StatusData{
-		Server:          serverName,
-		Status:          "Online",
-		Color:           "#4caf50",  // Material green
-		IsTestMode:      runtime.GOOS == "darwin",
-		ConfirmShutdown: true,
-		AskPassword:     false,
-	}
-	if err := tmpl.Execute(w, data); err != nil {
-		http.Error(w, "Failed to render template", http.StatusInternalServerError)
-		log.Printf("Template render error: %v", err)
-	}
-}
-
-// Handle password entry for shutdown
-func enterPasswordHandler(w http.ResponseWriter, r *http.Request) {
-	if !isServerOnline() {
-		// Server is already offline, redirect to home
-		http.Redirect(w, r, "/", http.StatusSeeOther)
+	// Check if shutdown password is set
+	if shutdownPassword == "" {
+		// Show error about missing password
+		data := StatusData{
+			Server:          serverName,
+			Status:          "Online",
+			Color:           "#4caf50", // Material green
+			IsTestMode:      runtime.GOOS == "darwin",
+			AskPassword:     false,
+			ConfirmShutdown: false,
+			ErrorMessage:    "SHUTDOWN_PASSWORD not set in environment. Please set it in the .env file.",
+			Schedule:        GetScheduleConfig(),
+			LastUpdated:     time.Now().Format("2006-01-02 15:04:05"),
+			RefreshInterval: refreshInterval,
+		}
+		if err := tmpl.Execute(w, data); err != nil {
+			http.Error(w, "Failed to render template", http.StatusInternalServerError)
+			log.Printf("Template render error: %v", err)
+		}
 		return
 	}

-	// Show password entry dialog
+	// Show confirmation dialog - we'll use the password from .env
 	data := StatusData{
-		Server:      serverName,
-		Status:      "Online",
-		Color:       "#4caf50",  // Material green
-		IsTestMode:  runtime.GOOS == "darwin",
-		AskPassword: true,
+		Server:          serverName,
+		Status:          "Online",
+		Color:           "#4caf50", // Material green
+		IsTestMode:      runtime.GOOS == "darwin",
+		ConfirmShutdown: true,
+		AskPassword:     false, // Make sure we don't ask for password
+		Schedule:        GetScheduleConfig(),
+		LastUpdated:     time.Now().Format("2006-01-02 15:04:05"),
 	}
+
+	// Notify the user if password is not configured
+	if shutdownPassword == "" {
+		data.ErrorMessage = "SHUTDOWN_PASSWORD not set in environment. Shutdown may fail."
+	}
+
 	if err := tmpl.Execute(w, data); err != nil {
 		http.Error(w, "Failed to render template", http.StatusInternalServerError)
 		log.Printf("Template render error: %v", err)
 	}
 }

+// Handle shutdown confirmation without password
+// enterPasswordHandler function removed - we now use the password from .env directly
+
 // Handle actual shutdown request
 func shutdownHandler(w http.ResponseWriter, r *http.Request) {
 	// Only process POST requests for security
@ -138,25 +170,20 @@ func shutdownHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}

-	// Parse form data to get password
-	if err := r.ParseForm(); err != nil {
-		log.Printf("Error parsing form: %v", err)
-		http.Redirect(w, r, "/", http.StatusSeeOther)
-		return
-	}
-
-	// Get password from form
-	password := r.FormValue("password")
-
-	if password == "" {
-		// Show password form again with error
+	// Use the password from environment variable
+	if shutdownPassword == "" {
+		log.Printf("SHUTDOWN_PASSWORD not set in environment, cannot perform shutdown")
+		// Show error message
 		data := StatusData{
-			Server:       serverName,
-			Status:       "Online",
-			Color:        "#4caf50",
-			IsTestMode:   runtime.GOOS == "darwin",
-			AskPassword:  true,
-			ErrorMessage: "Password cannot be empty",
+			Server:          serverName,
+			Status:          "Online",
+			Color:           "#4caf50",
+			IsTestMode:      runtime.GOOS == "darwin",
+			AskPassword:     false,
+			ErrorMessage:    "SHUTDOWN_PASSWORD not set in environment",
+			Schedule:        GetScheduleConfig(),
+			LastUpdated:     time.Now().Format("2006-01-02 15:04:05"),
+			RefreshInterval: refreshInterval,
 		}
 		if err := tmpl.Execute(w, data); err != nil {
 			http.Error(w, "Failed to render template", http.StatusInternalServerError)
@ -166,19 +193,22 @@ func shutdownHandler(w http.ResponseWriter, r *http.Request) {
 	}

 	if isServerOnline() {
-		// Shutdown the server
-		err := shutdownServer(password)
+		// Shutdown the server using the password from .env file
+		err := shutdownServer(shutdownPassword)
 		if err != nil {
 			log.Printf("Error shutting down server: %v", err)

-			// Show password form again with error
+			// Show error message
 			data := StatusData{
-				Server:       serverName,
-				Status:       "Online",
-				Color:        "#4caf50",
-				IsTestMode:   runtime.GOOS == "darwin",
-				AskPassword:  true,
-				ErrorMessage: "Failed to shutdown server. Please check your password.",
+				Server:          serverName,
+				Status:          "Online",
+				Color:           "#4caf50",
+				IsTestMode:      runtime.GOOS == "darwin",
+				AskPassword:     false, // No longer asking for password
+				ErrorMessage:    "Failed to shutdown server. Please check the password in .env file.",
+				Schedule:        GetScheduleConfig(),
+				LastUpdated:     time.Now().Format("2006-01-02 15:04:05"),
+				RefreshInterval: refreshInterval,
 			}
 			if err := tmpl.Execute(w, data); err != nil {
 				http.Error(w, "Failed to render template", http.StatusInternalServerError)
@ -189,11 +219,14 @@ func shutdownHandler(w http.ResponseWriter, r *http.Request) {

 		// Display shutting down status
 		data := StatusData{
-			Server:      serverName,
-			Status:      "Shutting down",
-			Color:       "#5d4037",  // Material brown
-			IsTestMode:  runtime.GOOS == "darwin",
-			AskPassword: false,
+			Server:          serverName,
+			Status:          "Shutting down",
+			Color:           "#5d4037", // Material brown
+			IsTestMode:      runtime.GOOS == "darwin",
+			AskPassword:     false,
+			Schedule:        GetScheduleConfig(),
+			LastUpdated:     time.Now().Format("2006-01-02 15:04:05"),
+			RefreshInterval: refreshInterval,
 		}
 		if err := tmpl.Execute(w, data); err != nil {
 			http.Error(w, "Failed to render template", http.StatusInternalServerError)
@ -202,11 +235,14 @@ func shutdownHandler(w http.ResponseWriter, r *http.Request) {
 	} else {
 		// Server is already offline
 		data := StatusData{
-			Server:      serverName,
-			Status:      "Offline",
-			Color:       "#d32f2f",  // Material red
-			IsTestMode:  runtime.GOOS == "darwin",
-			AskPassword: false,
+			Server:          serverName,
+			Status:          "Offline",
+			Color:           "#d32f2f", // Material red
+			IsTestMode:      runtime.GOOS == "darwin",
+			AskPassword:     false,
+			Schedule:        GetScheduleConfig(),
+			LastUpdated:     time.Now().Format("2006-01-02 15:04:05"),
+			RefreshInterval: refreshInterval,
 		}
 		if err := tmpl.Execute(w, data); err != nil {
 			http.Error(w, "Failed to render template", http.StatusInternalServerError)
--- a/main.go
+++ b/main.go
@ -1,21 +1,27 @@
 package main

 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
 	"log"
 	"net/http"
 	"os"
+	"os/exec"
 	"runtime"
+	"strconv"
+	"time"

 	"github.com/joho/godotenv"
 )

 // Default values
 var (
-	serverName = "server"           // Server to ping
-	serverUser = "root"               // SSH username
-	macAddress = "aa:aa:aa:aa:aa:aa"  // MAC address of the server
-	port       = "8080"               // Port to listen on
+	serverName      = "server"            // Server to ping
+	serverUser      = "root"              // SSH username
+	macAddress      = "aa:aa:aa:aa:aa:aa" // MAC address of the server
+	port            = "8080"              // Port to listen on
+	refreshInterval = 60                  // UI refresh interval in seconds
 )

 func loadEnvVariables() {
@ -41,8 +47,15 @@ func loadEnvVariables() {
 		port = envPort
 	}

-	log.Printf("Configuration loaded: SERVER_NAME=%s, SERVER_USER=%s, MAC_ADDRESS=%s, PORT=%s",
-		serverName, serverUser, macAddress, port)
+	// Load refresh interval if set
+	if envRefresh := os.Getenv("REFRESH_INTERVAL"); envRefresh != "" {
+		if val, err := strconv.Atoi(envRefresh); err == nil && val > 0 {
+			refreshInterval = val
+		}
+	}
+
+	log.Printf("Configuration loaded: SERVER_NAME=%s, SERVER_USER=%s, MAC_ADDRESS=%s, PORT=%s, REFRESH=%d",
+		serverName, serverUser, macAddress, port, refreshInterval)
 }

 func main() {
@ -54,13 +67,24 @@ func main() {
 		log.Fatalf("Failed to setup template: %v", err)
 	}

+	// Verify schedule configuration and clean up stale schedule data if needed
+	verifyScheduleConfig()
+
+	// Setup a ticker to check schedule and perform actions
+	go runScheduleChecker()
+
 	// Register route handlers
 	http.HandleFunc("/", indexHandler)
 	http.HandleFunc("/boot", bootHandler)
 	http.HandleFunc("/confirm-shutdown", confirmShutdownHandler)
-	http.HandleFunc("/enter-password", enterPasswordHandler)
+	// Password is now taken directly from .env file
 	http.HandleFunc("/shutdown", shutdownHandler)

+	// Schedule API endpoints
+	http.HandleFunc("/api/schedule", scheduleHandler)
+	// API shutdown endpoint
+	http.HandleFunc("/api/shutdown", apiShutdownHandler)
+
 	// Start the server
 	listenAddr := fmt.Sprintf(":%s", port)
 	log.Printf("Starting WOL Server on http://localhost%s", listenAddr)
@ -73,3 +97,364 @@ func main() {
 		log.Fatalf("Server failed to start: %v", err)
 	}
 }
+
+// API Shutdown handler - shuts down the server with password from environment
+func apiShutdownHandler(w http.ResponseWriter, r *http.Request) {
+	// Add cache control headers to prevent caching
+	w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+	w.Header().Set("Pragma", "no-cache")
+	w.Header().Set("Expires", "0")
+	// Set content type for JSON response
+	w.Header().Set("Content-Type", "application/json")
+
+	// Only allow POST requests
+	if r.Method != "POST" {
+		w.WriteHeader(http.StatusMethodNotAllowed)
+		json.NewEncoder(w).Encode(map[string]interface{}{
+			"success": false,
+			"error":   "Method not allowed. Use POST.",
+		})
+		return
+	}
+
+	// Check if shutdown password is available in environment
+	if shutdownPassword == "" {
+		w.WriteHeader(http.StatusInternalServerError)
+		json.NewEncoder(w).Encode(map[string]interface{}{
+			"success": false,
+			"error":   "SHUTDOWN_PASSWORD not set in environment",
+		})
+		return
+	}
+
+	// Check if server is online before attempting shutdown
+	if !isServerOnline() {
+		// Server is already offline
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]interface{}{
+			"success": false,
+			"error":   "Server is already offline",
+		})
+		return
+	}
+
+	// Try to shut down the server using the password from environment
+	err := shutdownServer(shutdownPassword)
+	if err != nil {
+		// Shutdown command failed
+		w.WriteHeader(http.StatusInternalServerError)
+		json.NewEncoder(w).Encode(map[string]interface{}{
+			"success": false,
+			"error":   "Failed to shutdown server: " + err.Error(),
+		})
+		log.Printf("API shutdown failed: %v", err)
+		return
+	}
+
+	// Shutdown initiated successfully
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"success": true,
+		"message": "Server shutdown initiated",
+	})
+	log.Printf("API shutdown successful")
+}
+
+// Handle schedule API requests
+func scheduleHandler(w http.ResponseWriter, r *http.Request) {
+	// Set content type
+	w.Header().Set("Content-Type", "application/json")
+
+	// Handle GET request - return current schedule
+	if r.Method == "GET" {
+		data, err := json.Marshal(GetScheduleConfig())
+		if err != nil {
+			http.Error(w, fmt.Sprintf(`{"error": "Failed to marshal schedule data: %v"}`, err), http.StatusInternalServerError)
+			return
+		}
+		w.Write(data)
+		return
+	}
+
+	// Handle POST request - update schedule
+	if r.Method == "POST" {
+		var newConfig ScheduleConfig
+		err := json.NewDecoder(r.Body).Decode(&newConfig)
+		if err != nil {
+			http.Error(w, fmt.Sprintf(`{"error": "Failed to parse request body: %v"}`, err), http.StatusBadRequest)
+			return
+		}
+
+		// Validate the schedule data
+		if newConfig.Enabled {
+			// Validate time format (HH:MM)
+			_, err = time.Parse("15:04", newConfig.StartTime)
+			if err != nil {
+				http.Error(w, `{"error": "Invalid start time format. Use 24-hour format (HH:MM)"}`, http.StatusBadRequest)
+				return
+			}
+
+			_, err = time.Parse("15:04", newConfig.EndTime)
+			if err != nil {
+				http.Error(w, `{"error": "Invalid end time format. Use 24-hour format (HH:MM)"}`, http.StatusBadRequest)
+				return
+			}
+
+			// Validate frequency
+			validFrequencies := map[string]bool{
+				"daily":      true,
+				"every2days": true,
+				"weekly":     true,
+				"monthly":    true,
+			}
+
+			if !validFrequencies[newConfig.Frequency] {
+				http.Error(w, `{"error": "Invalid frequency. Use 'daily', 'every2days', 'weekly', or 'monthly'"}`, http.StatusBadRequest)
+				return
+			}
+
+			// Reset lastRun if it wasn't set
+			if newConfig.LastRun == "" {
+				newConfig.LastRun = ""
+			}
+
+			// If auto shutdown is enabled, make sure we have a password in env
+			if newConfig.AutoShutdown && shutdownPassword == "" {
+				http.Error(w, `{"error": "SHUTDOWN_PASSWORD not set in environment. Please set it before enabling auto-shutdown"}`, http.StatusBadRequest)
+				return
+			}
+
+			// Check if SSH connection can be established with the password
+			if newConfig.AutoShutdown && shutdownPassword != "" {
+				log.Printf("Testing SSH connection to %s with provided password", serverName)
+
+				// We'll just check if the server is reachable first
+				if !isServerOnline() {
+					log.Printf("Server %s is not online, can't test SSH connection", serverName)
+				} else {
+					// Try to run a harmless command to test SSH connection
+					cmd := exec.Command("sshpass", "-p", shutdownPassword, "ssh",
+						"-o", "StrictHostKeyChecking=no",
+						"-o", "UserKnownHostsFile=/dev/null",
+						"-o", "LogLevel=ERROR",
+						"-o", "ConnectTimeout=5",
+						fmt.Sprintf("%s@%s", serverUser, serverName),
+						"echo", "SSH connection test successful")
+
+					var stderr bytes.Buffer
+					cmd.Stderr = &stderr
+
+					if err := cmd.Run(); err != nil {
+						log.Printf("SSH connection test failed: %v - %s", err, stderr.String())
+						// We don't prevent saving the config even if test fails
+						// Just log a warning for now
+						log.Printf("WARNING: Auto shutdown may not work with the provided password")
+					} else {
+						log.Printf("SSH connection test successful")
+					}
+				}
+			}
+		}
+
+		// Save the new configuration
+		err = UpdateScheduleConfig(newConfig)
+		if err != nil {
+			http.Error(w, fmt.Sprintf(`{"error": "Failed to save schedule config: %v"}`, err), http.StatusInternalServerError)
+			return
+		}
+
+		// Return the updated config
+		data, err := json.Marshal(GetScheduleConfig())
+		if err != nil {
+			http.Error(w, fmt.Sprintf(`{"error": "Failed to marshal schedule data: %v"}`, err), http.StatusInternalServerError)
+			return
+		}
+		w.Write(data)
+		return
+	}
+
+	// Method not allowed
+	http.Error(w, `{"error": "Method not allowed"}`, http.StatusMethodNotAllowed)
+}
+
+// Verify and clean up schedule configuration
+func verifyScheduleConfig() {
+	// If schedule is enabled, validate all required fields
+	if scheduleConfig.Enabled {
+		log.Println("Verifying schedule configuration...")
+		log.Printf("Current config: StartTime=%s, EndTime=%s, Frequency=%s, AutoShutdown=%v",
+			scheduleConfig.StartTime, scheduleConfig.EndTime, scheduleConfig.Frequency, scheduleConfig.AutoShutdown)
+
+		// Check for valid time formats
+		_, startErr := time.Parse("15:04", scheduleConfig.StartTime)
+		_, endErr := time.Parse("15:04", scheduleConfig.EndTime)
+
+		if startErr != nil || endErr != nil || scheduleConfig.StartTime == "" || scheduleConfig.EndTime == "" {
+			log.Println("Warning: Invalid time format in schedule configuration, disabling schedule")
+			scheduleConfig.Enabled = false
+			UpdateScheduleConfig(scheduleConfig)
+			return
+		}
+
+		// Immediately check if we need to boot ONLY at exact start time
+		now := time.Now()
+		currentTimeStr := now.Format("15:04")
+
+		// Check ONLY if current time EXACTLY matches start time
+		if currentTimeStr == scheduleConfig.StartTime && ShouldRunToday(now) {
+			log.Printf("STARTUP MATCH: Current time %s matches start time EXACTLY, attempting boot", currentTimeStr)
+			if !isServerOnline() {
+				sendWakeOnLAN()
+				// Mark that the server was started by the scheduler
+				scheduleConfig.StartedBySchedule = true
+				scheduleConfig.LastRun = now.Format(time.RFC3339)
+				UpdateScheduleConfig(scheduleConfig)
+			}
+		}
+
+		// Check for valid frequency
+		validFrequencies := map[string]bool{
+			"daily":      true,
+			"every2days": true,
+			"weekly":     true,
+			"monthly":    true,
+		}
+
+		if !validFrequencies[scheduleConfig.Frequency] {
+			log.Println("Warning: Invalid frequency in schedule configuration, setting to daily")
+			scheduleConfig.Frequency = "daily"
+			UpdateScheduleConfig(scheduleConfig)
+		}
+
+		log.Printf("Schedule configuration verified: Start=%s, End=%s, Frequency=%s",
+			scheduleConfig.StartTime, scheduleConfig.EndTime, scheduleConfig.Frequency)
+	}
+}
+
+// Run a periodic check of schedule and take appropriate actions
+func runScheduleChecker() {
+	// Define the checkScheduleOnce function
+	checkScheduleOnce := func() {
+		// Only check exact times for schedule actions, don't use window logic
+		now := time.Now()
+		currentTimeStr := now.Format("15:04")
+		serverIsOn := isServerOnline()
+
+		// Log schedule status (debug level)
+		if scheduleConfig.Enabled {
+			log.Printf("Schedule check: Current=%s, Start=%s, End=%s, LastRun=%s",
+				currentTimeStr, scheduleConfig.StartTime, scheduleConfig.EndTime, scheduleConfig.LastRun)
+
+			// Only act at exact start or end times
+			// EXACT START TIME MATCH - Try to boot server
+			if currentTimeStr == scheduleConfig.StartTime && !serverIsOn && ShouldRunToday(now) {
+				log.Println("EXACT START TIME: Initiating boot sequence...")
+
+				// Try multiple times to boot with small delays between attempts
+				for attempt := 1; attempt <= 3; attempt++ {
+					log.Printf("Boot attempt %d/3", attempt)
+					err := sendWakeOnLAN()
+					if err != nil {
+						log.Printf("Error booting server from schedule: %v", err)
+					} else {
+						log.Println("Schedule: Boot command sent successfully")
+						// Mark that server was started by scheduler
+						scheduleConfig.StartedBySchedule = true
+						scheduleConfig.LastRun = now.Format(time.RFC3339)
+						UpdateScheduleConfig(scheduleConfig)
+					}
+
+					// Check if server came online
+					time.Sleep(3 * time.Second) // Extended wait time for boot check
+					if isServerOnline() {
+						log.Println("Server successfully booted!")
+						break
+					}
+
+					// Short delay before next attempt
+					if attempt < 3 {
+						time.Sleep(1 * time.Second)
+					}
+				}
+				// EXACT END TIME MATCH - Try to shutdown server
+			} else if currentTimeStr == scheduleConfig.EndTime && serverIsOn {
+				// Check if auto-shutdown is enabled
+				if scheduleConfig.AutoShutdown && shutdownPassword != "" && scheduleConfig.StartedBySchedule {
+					log.Println("EXACT END TIME: Attempting auto-shutdown")
+
+					// Try multiple times to shut down the server
+					var shutdownSuccessful bool
+					for attempt := 1; attempt <= 3; attempt++ {
+						log.Printf("Auto shutdown attempt %d/3", attempt)
+						err := shutdownServer(shutdownPassword)
+						if err != nil {
+							log.Printf("Auto shutdown attempt %d failed: %v", attempt, err)
+							if attempt < 3 {
+								time.Sleep(3 * time.Second)
+							}
+						} else {
+							log.Printf("Auto shutdown initiated successfully on attempt %d", attempt)
+							shutdownSuccessful = true
+							break
+						}
+					}
+
+					if !shutdownSuccessful {
+						log.Printf("All auto shutdown attempts failed")
+					}
+				}
+			} else {
+				// No action at non-exact times, just log status
+				if serverIsOn && scheduleConfig.StartedBySchedule && currentTimeStr > scheduleConfig.EndTime {
+					log.Printf("Server is still online after end time %s - waiting for next exact end time match", scheduleConfig.EndTime)
+				}
+			}
+		}
+
+		// Update last run timestamp if we've passed the end time
+		// This helps track when the schedule was last active
+		currentConfig := GetScheduleConfig()
+		nowTime := time.Now()
+		currentTimeString := nowTime.Format("15:04")
+		if currentConfig.Enabled && currentTimeString > currentConfig.EndTime && currentConfig.LastRun != "" {
+			lastRun, err := time.Parse(time.RFC3339, currentConfig.LastRun)
+			if err == nil {
+				// If it's been more than a day since the last update, reset the timestamp
+				// This allows the schedule to run again based on frequency
+				if time.Since(lastRun) > 24*time.Hour {
+					log.Println("Schedule: Resetting last run timestamp for next scheduled run")
+					currentConfig.LastRun = ""
+					UpdateScheduleConfig(currentConfig)
+				}
+			}
+		}
+	}
+
+	// Use a slightly shorter interval for more responsive scheduling
+	// First check immediately at startup
+	checkScheduleOnce()
+
+	// Then set up regular checks
+	ticker := time.NewTicker(5 * time.Second)
+	defer ticker.Stop()
+
+	log.Println("Schedule checker started - checking every 5 seconds")
+	log.Printf("Current schedule: enabled=%v, startTime=%s, endTime=%s, frequency=%s, autoShutdown=%v",
+		scheduleConfig.Enabled, scheduleConfig.StartTime, scheduleConfig.EndTime, scheduleConfig.Frequency, scheduleConfig.AutoShutdown)
+
+	for {
+		func() {
+			// Recover from any panics that might occur in the schedule checker
+			defer func() {
+				if r := recover(); r != nil {
+					log.Printf("Recovered from panic in schedule checker: %v", r)
+				}
+			}()
+
+			checkScheduleOnce()
+		}()
+
+		// Wait for next tick
+		<-ticker.C
+	}
+}
--- a/schedule.json
+++ b/schedule.json
@ -0,0 +1,9 @@
+{
+  "enabled": true,
+  "startTime": "13:46",
+  "endTime": "13:49",
+  "frequency": "daily",
+  "lastRun": "2025-09-05T13:46:41+02:00",
+  "autoShutdown": true,
+  "startedBySchedule": true
+}
--- a/templates/status.html
+++ b/templates/status.html
--- a/utils.go
+++ b/utils.go
@ -2,6 +2,7 @@ package main

 import (
 	"bytes"
+	"encoding/json"
 	"fmt"
 	"html/template"
 	"log"
@ -9,8 +10,20 @@ import (
 	"os/exec"
 	"path/filepath"
 	"runtime"
+	"time"
 )

+// ScheduleConfig holds the backup window schedule settings
+type ScheduleConfig struct {
+	Enabled           bool   `json:"enabled"`
+	StartTime         string `json:"startTime"`         // Format: "HH:MM" (24-hour)
+	EndTime           string `json:"endTime"`           // Format: "HH:MM" (24-hour)
+	Frequency         string `json:"frequency"`         // "daily", "every2days", "weekly", "monthly"
+	LastRun           string `json:"lastRun"`           // ISO8601 format - when the schedule last ran
+	AutoShutdown      bool   `json:"autoShutdown"`      // Whether to automatically shut down at end time
+	StartedBySchedule bool   `json:"startedBySchedule"` // Whether server was started by scheduler
+}
+
 // StatusData holds data for the HTML template
 type StatusData struct {
 	Server          string
@ -20,9 +33,15 @@ type StatusData struct {
 	ConfirmShutdown bool
 	AskPassword     bool
 	ErrorMessage    string
+	Schedule        ScheduleConfig
+	LastUpdated     string
+	RefreshInterval int
 }

 var tmpl *template.Template
+var scheduleConfig ScheduleConfig
+var scheduleConfigPath = "schedule.json"
+var shutdownPassword string // Will be loaded from environment

 // Setup the HTML template
 func setupTemplate() error {
@ -49,12 +68,362 @@ func setupTemplate() error {
 		return fmt.Errorf("failed to parse template: %v", err)
 	}

+	// Load schedule config
+	err = loadScheduleConfig()
+	if err != nil {
+		log.Printf("Warning: Failed to load schedule config: %v", err)
+		// Continue with default (empty) schedule config
+	}
+
+	// Check for required system tools
+	checkRequiredTools()
+
+	// Load shutdown password from environment
+	shutdownPassword = os.Getenv("SHUTDOWN_PASSWORD")
+	if shutdownPassword == "" {
+		log.Println("SHUTDOWN_PASSWORD not set in environment. Automatic shutdown will be disabled.")
+	} else {
+		log.Println("SHUTDOWN_PASSWORD loaded from environment")
+	}
+
 	return nil
 }

+// Check if required system tools are available
+func checkRequiredTools() {
+	// Check for wakeonlan command
+	if _, err := exec.LookPath("wakeonlan"); err != nil {
+		if _, err := exec.LookPath("etherwake"); err != nil {
+			if _, err := exec.LookPath("wol"); err != nil {
+				log.Printf("WARNING: No Wake-on-LAN tools found. Please install wakeonlan, etherwake, or wol package.")
+				log.Printf("Installation instructions:")
+				log.Printf("  - For Debian/Ubuntu: sudo apt-get install wakeonlan")
+				log.Printf("  - For macOS: brew install wakeonlan")
+				log.Printf("  - For Windows: Download from https://www.depicus.com/wake-on-lan/wake-on-lan-cmd")
+			} else {
+				log.Printf("Using 'wol' for Wake-on-LAN functionality")
+			}
+		} else {
+			log.Printf("Using 'etherwake' for Wake-on-LAN functionality")
+		}
+	} else {
+		log.Printf("Found 'wakeonlan' command for Wake-on-LAN functionality")
+	}
+
+	// Check for ping command (needed for server status checks)
+	if _, err := exec.LookPath("ping"); err != nil {
+		log.Printf("WARNING: 'ping' command not found. Server status checks may fail.")
+	}
+}
+
+// Load schedule configuration from file
+func loadScheduleConfig() error {
+	// Check if config file exists
+	if _, err := os.Stat(scheduleConfigPath); os.IsNotExist(err) {
+		// Create default config
+		scheduleConfig = ScheduleConfig{
+			Enabled:           false,
+			StartTime:         "",
+			EndTime:           "",
+			Frequency:         "daily",
+			LastRun:           "",
+			AutoShutdown:      false,
+			StartedBySchedule: false,
+		}
+		// Save default config
+		return saveScheduleConfig()
+	}
+
+	// Read the file
+	data, err := os.ReadFile(scheduleConfigPath)
+	if err != nil {
+		return fmt.Errorf("failed to read schedule config file: %v", err)
+	}
+
+	// Unmarshal JSON data
+	err = json.Unmarshal(data, &scheduleConfig)
+	if err != nil {
+		return fmt.Errorf("failed to parse schedule config: %v", err)
+	}
+
+	// Log loaded configuration for debugging
+	log.Printf("Loaded schedule config: Enabled=%v, StartTime=%s, EndTime=%s, Frequency=%s",
+		scheduleConfig.Enabled, scheduleConfig.StartTime, scheduleConfig.EndTime, scheduleConfig.Frequency)
+
+	return nil
+}
+
+// Save schedule configuration to file
+func saveScheduleConfig() error {
+	data, err := json.MarshalIndent(scheduleConfig, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal schedule config: %v", err)
+	}
+
+	err = os.WriteFile(scheduleConfigPath, data, 0644)
+	if err != nil {
+		return fmt.Errorf("failed to save schedule config: %v", err)
+	}
+
+	return nil
+}
+
+// GetScheduleConfig returns the current schedule config
+func GetScheduleConfig() ScheduleConfig {
+	return scheduleConfig
+}
+
+// UpdateScheduleConfig updates the schedule configuration
+func UpdateScheduleConfig(newConfig ScheduleConfig) error {
+	scheduleConfig = newConfig
+	return saveScheduleConfig()
+}
+
+// CheckSchedule checks if server should be on/off based on schedule
+func CheckSchedule() (shouldBeOn bool) {
+	// If schedule is not enabled, do nothing
+	if !scheduleConfig.Enabled {
+		return false
+	}
+
+	// If start time or end time is empty, the schedule is not properly configured
+	if scheduleConfig.StartTime == "" || scheduleConfig.EndTime == "" {
+		log.Printf("Schedule configuration incomplete: StartTime=%s, EndTime=%s",
+			scheduleConfig.StartTime, scheduleConfig.EndTime)
+		return false
+	}
+
+	now := time.Now()
+	today := now.Format("2006-01-02")
+
+	// Get current time as just hours and minutes for direct string comparison first
+	currentTimeStr := now.Format("15:04")
+
+	// Log the exact time comparison we're doing
+	log.Printf("Schedule debug: Current=%s, Start=%s, End=%s, LastRun=%s",
+		currentTimeStr, scheduleConfig.StartTime, scheduleConfig.EndTime, scheduleConfig.LastRun)
+
+	// Parse start time with proper error handling
+	startTime, err := time.Parse("2006-01-02 15:04", fmt.Sprintf("%s %s", today, scheduleConfig.StartTime))
+	if err != nil {
+		log.Printf("Error parsing start time '%s': %v", scheduleConfig.StartTime, err)
+		return false
+	}
+
+	// Parse end time with proper error handling
+	endTime, err := time.Parse("2006-01-02 15:04", fmt.Sprintf("%s %s", today, scheduleConfig.EndTime))
+	if err != nil {
+		log.Printf("Error parsing end time '%s': %v", scheduleConfig.EndTime, err)
+		return false
+	}
+
+	// If end time is before start time, it means the window spans to the next day
+	if endTime.Before(startTime) {
+		endTime = endTime.AddDate(0, 0, 1)
+
+		// Special case: if we're after midnight but before the end time
+		// we need to adjust the start time to be from yesterday
+		if now.Before(endTime) && now.After(time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())) {
+			startTime = startTime.AddDate(0, 0, -1)
+		}
+	}
+
+	// Check if the schedule should run today based on frequency
+	// Check if we're in the schedule window
+	if !ShouldRunToday(now) {
+		log.Printf("Schedule is active but not set to run today based on frequency: %s", scheduleConfig.Frequency)
+		return false
+	}
+
+	// Check for auto shutdown at end time
+	if currentTimeStr == scheduleConfig.EndTime {
+		if scheduleConfig.AutoShutdown && shutdownPassword != "" && isServerOnline() {
+			// Only shut down if the server was started by the scheduler
+			if scheduleConfig.StartedBySchedule {
+				log.Printf("Auto shutdown triggered at schedule end time %s", scheduleConfig.EndTime)
+
+				// Try up to 3 times to shut down the server
+				var shutdownSuccessful bool
+				for attempt := 1; attempt <= 3; attempt++ {
+					log.Printf("Auto shutdown attempt %d/3", attempt)
+					err := shutdownServer(shutdownPassword)
+					if err != nil {
+						log.Printf("Auto shutdown attempt %d failed: %v", attempt, err)
+						if attempt < 3 {
+							time.Sleep(3 * time.Second)
+						}
+					} else {
+						log.Printf("Auto shutdown initiated successfully on attempt %d", attempt)
+						shutdownSuccessful = true
+						break
+					}
+				}
+
+				if !shutdownSuccessful {
+					log.Printf("All auto shutdown attempts failed")
+				}
+			} else {
+				log.Printf("Server was not started by scheduler, skipping auto shutdown")
+			}
+		}
+	}
+
+	// Check if current time is within the schedule window
+	// Check if we're between start and end times
+	if currentTimeStr == scheduleConfig.StartTime {
+		log.Printf("Schedule match: Current time exactly matches start time")
+		shouldBeOn = true
+	} else if currentTimeStr == scheduleConfig.EndTime {
+		log.Printf("Schedule end: Current time exactly matches end time")
+		shouldBeOn = false
+
+		// Check if auto shutdown is enabled
+		if scheduleConfig.AutoShutdown && shutdownPassword != "" && isServerOnline() {
+			// Only shut down if the server was started by the scheduler
+			if scheduleConfig.StartedBySchedule {
+				log.Printf("Auto shutdown is enabled - attempting to shut down server at end time")
+
+				// Try up to 3 times to shut down the server
+				var shutdownSuccessful bool
+				for attempt := 1; attempt <= 3; attempt++ {
+					log.Printf("Auto shutdown attempt %d/3", attempt)
+					err := shutdownServer(shutdownPassword)
+					if err != nil {
+						log.Printf("Auto shutdown attempt %d failed: %v", attempt, err)
+						if attempt < 3 {
+							time.Sleep(3 * time.Second)
+						}
+					} else {
+						log.Printf("Auto shutdown initiated successfully on attempt %d", attempt)
+						shutdownSuccessful = true
+						break
+					}
+				}
+
+				if !shutdownSuccessful {
+					log.Printf("All auto shutdown attempts failed")
+				}
+			} else {
+				log.Printf("Server was not started by scheduler, skipping auto shutdown")
+			}
+		}
+	} else {
+		// ONLY consider the server should be on at EXACT start time or EXACT end time
+		shouldBeOn = (currentTimeStr == scheduleConfig.StartTime)
+
+		// Log that we're waiting for exact times for actions
+		if currentTimeStr != scheduleConfig.StartTime && currentTimeStr != scheduleConfig.EndTime {
+			log.Printf("Not at exact schedule times - no action needed until exact start/end time")
+		}
+	}
+
+	log.Printf("Schedule window check: Current=%v, Start=%v, End=%v, ShouldBeOn=%v",
+		now.Format("15:04:05"), startTime.Format("15:04:05"), endTime.Format("15:04:05"), shouldBeOn)
+
+	// Explicitly check end time for better debugging
+	if scheduleConfig.EndTime != "" && currentTimeStr == scheduleConfig.EndTime {
+		log.Printf("EXACT END TIME MATCH! Current time %s equals end time - schedule window should close", currentTimeStr)
+	}
+
+	// If we're at exact start time, update the LastRun timestamp
+	if currentTimeStr == scheduleConfig.StartTime && ShouldRunToday(now) {
+		// We only track that we've seen the start time
+		log.Printf("Exact start time reached - marking schedule run")
+
+		// Don't automatically boot the server here - let the main scheduler handle it
+		// We're just updating state information
+		scheduleConfig.LastRun = now.Format(time.RFC3339)
+		if err := saveScheduleConfig(); err != nil {
+			log.Printf("Warning: Failed to save schedule config: %v", err)
+		}
+	}
+
+	return shouldBeOn
+}
+
+// ShouldRunToday checks if the schedule should run today based on frequency
+func ShouldRunToday(now time.Time) bool {
+	// We no longer check for windows - we only check at exact times
+	currentTimeStr := now.Format("15:04")
+	today := now.Format("2006-01-02")
+
+	startTime, startErr := time.Parse("2006-01-02 15:04", fmt.Sprintf("%s %s", today, scheduleConfig.StartTime))
+	endTime, endErr := time.Parse("2006-01-02 15:04", fmt.Sprintf("%s %s", today, scheduleConfig.EndTime))
+
+	if startErr == nil && endErr == nil {
+		// If end time is before start time, it means the window spans to the next day
+		if endTime.Before(startTime) {
+			endTime = endTime.AddDate(0, 0, 1)
+		}
+
+		// Only log that we're at an exact schedule time
+		if currentTimeStr == scheduleConfig.StartTime {
+			log.Println("Currently at exact start time - schedule should be active")
+			return true
+		}
+	}
+
+	// If no previous run, allow it to run
+	if scheduleConfig.LastRun == "" {
+		log.Println("No previous run recorded, schedule can run today")
+		return true
+	}
+
+	lastRun, err := time.Parse(time.RFC3339, scheduleConfig.LastRun)
+	if err != nil {
+		log.Printf("Error parsing last run date '%s': %v", scheduleConfig.LastRun, err)
+		// If we can't parse the date, better to let it run than to block it
+		return true
+	}
+
+	// Don't allow running multiple times on the same day unless
+	// it's been reset explicitly (LastRun set to empty)
+	if lastRun.Year() == now.Year() && lastRun.YearDay() == now.YearDay() {
+		// Check if we've passed the end time today - if so, we can reset for next run
+		if scheduleConfig.EndTime != "" && currentTimeStr > scheduleConfig.EndTime {
+			log.Println("Current time is after end time - resetting for next run")
+			scheduleConfig.LastRun = ""
+			scheduleConfig.StartedBySchedule = false // Reset this flag too
+			saveScheduleConfig()
+			return false
+		}
+
+		log.Println("Schedule already ran today, skipping")
+		return false
+	}
+
+	switch scheduleConfig.Frequency {
+	case "daily":
+		// Run every day
+		log.Println("Daily schedule: allowed to run today")
+		return true
+	case "every2days":
+		// Check if at least 2 days have passed
+		elapsed := now.Sub(lastRun)
+		eligible := elapsed >= 48*time.Hour
+		log.Printf("Every 2 days schedule: %v hours elapsed, eligible=%v", elapsed.Hours(), eligible)
+		return eligible
+	case "weekly":
+		// Check if at least 7 days have passed
+		elapsed := now.Sub(lastRun)
+		eligible := elapsed >= 7*24*time.Hour
+		log.Printf("Weekly schedule: %v days elapsed, eligible=%v", elapsed.Hours()/24, eligible)
+		return eligible
+	case "monthly":
+		// Check if last run was in a different month
+		sameMonth := lastRun.Month() == now.Month() && lastRun.Year() == now.Year()
+		log.Printf("Monthly schedule: eligible=%v", !sameMonth)
+		return !sameMonth
+	default:
+		log.Printf("Unknown frequency '%s', defaulting to daily", scheduleConfig.Frequency)
+		return true
+	}
+}
+
 // Check if server is online
 func isServerOnline() bool {
 	var cmd *exec.Cmd
+	var stdout, stderr bytes.Buffer

 	// macOS and Linux have slightly different ping commands
 	if runtime.GOOS == "darwin" {
@ -63,38 +432,186 @@ func isServerOnline() bool {
 		cmd = exec.Command("ping", "-c", "1", "-W", "1", serverName)
 	}

+	// Capture output for debugging
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	log.Printf("Checking if server %s is online...", serverName)
 	err := cmd.Run()
-	return err == nil
+
+	if err != nil {
+		// Only log the full error in debug mode to avoid spamming the logs
+		if stderr.String() != "" {
+			log.Printf("Server %s is offline: %v - %s", serverName, err, stderr.String())
+		} else {
+			log.Printf("Server %s is offline", serverName)
+		}
+		return false
+	}
+
+	log.Printf("Server %s is online", serverName)
+	return true
 }

 // Send WOL packet
 func sendWakeOnLAN() error {
 	log.Printf("Sending WOL packet to %s (%s)", serverName, macAddress)
-	cmd := exec.Command("wakeonlan", macAddress)
-	return cmd.Run()
+
+	// Check if wakeonlan command exists
+	if _, err := exec.LookPath("wakeonlan"); err == nil {
+		// Create the command
+		cmd := exec.Command("wakeonlan", macAddress)
+
+		// Capture both stdout and stderr
+		var stdout, stderr bytes.Buffer
+		cmd.Stdout = &stdout
+		cmd.Stderr = &stderr
+
+		// Execute the command
+		err := cmd.Run()
+
+		// Log the result
+		if err != nil {
+			log.Printf("WOL command failed: %v - stderr: %s", err, stderr.String())
+			return fmt.Errorf("WOL command failed: %v - %s", err, stderr.String())
+		}
+
+		output := stdout.String()
+		if output != "" {
+			log.Printf("WOL command output: %s", output)
+		}
+
+		log.Printf("WOL packet sent successfully to %s", macAddress)
+		return nil
+	} else {
+		// wakeonlan command not found, try etherwake
+		if _, err := exec.LookPath("etherwake"); err == nil {
+			log.Printf("Using etherwake as wakeonlan alternative")
+			cmd := exec.Command("etherwake", macAddress)
+
+			var stdout, stderr bytes.Buffer
+			cmd.Stdout = &stdout
+			cmd.Stderr = &stderr
+
+			err := cmd.Run()
+			if err != nil {
+				log.Printf("etherwake command failed: %v - stderr: %s", err, stderr.String())
+				return fmt.Errorf("etherwake command failed: %v - %s", err, stderr.String())
+			}
+
+			log.Printf("WOL packet sent successfully via etherwake to %s", macAddress)
+			return nil
+		} else {
+			// Try wol command as last resort
+			if _, err := exec.LookPath("wol"); err == nil {
+				log.Printf("Using wol as wakeonlan alternative")
+				cmd := exec.Command("wol", macAddress)
+
+				var stdout, stderr bytes.Buffer
+				cmd.Stdout = &stdout
+				cmd.Stderr = &stderr
+
+				err := cmd.Run()
+				if err != nil {
+					log.Printf("wol command failed: %v - stderr: %s", err, stderr.String())
+					return fmt.Errorf("wol command failed: %v - %s", err, stderr.String())
+				}
+
+				log.Printf("WOL packet sent successfully via wol to %s", macAddress)
+				return nil
+			} else {
+				// Implement a fallback pure Go WOL solution
+				log.Printf("No WOL tools found. Please install wakeonlan, etherwake, or wol package.")
+				log.Printf("Installation instructions:")
+				log.Printf("  - For Debian/Ubuntu: sudo apt-get install wakeonlan")
+				log.Printf("  - For macOS: brew install wakeonlan")
+				log.Printf("  - For Windows: Download from https://www.depicus.com/wake-on-lan/wake-on-lan-cmd")
+
+				return fmt.Errorf("wakeonlan command not found in PATH. Please install wakeonlan tool")
+			}
+		}
+	}
 }

 // Shutdown server with password
 func shutdownServer(password string) error {
-    log.Printf("Sending shutdown command to %s", serverName)
+	log.Printf("Sending shutdown command to %s", serverName)

-    // Add more SSH options to handle potential issues
-    cmd := exec.Command("sshpass", "-p", password, "ssh",
-        "-o", "StrictHostKeyChecking=no",
-        "-o", "UserKnownHostsFile=/dev/null",
-        "-o", "LogLevel=ERROR",
-        fmt.Sprintf("%s@%s", serverUser, serverName),
-        "sudo", "-S", "shutdown", "-h", "now")
+	var err error
+	var stderr bytes.Buffer

-    // Capture stderr to log any error messages
-    var stderr bytes.Buffer
-    cmd.Stderr = &stderr
+	// First try using sshpass with password
+	if _, err := exec.LookPath("sshpass"); err == nil {
+		log.Println("Using sshpass for authentication")
+		log.Printf("Password being used: %s", password)

-    err := cmd.Run()
-    if err != nil {
-        log.Printf("SSH Error details: %s", stderr.String())
-        return fmt.Errorf("SSH command failed: %v - %s", err, stderr.String())
-    }
+		// Add more SSH options to handle potential issues
+		cmd := exec.Command("sshpass", "-p", password, "ssh",
+			"-o", "StrictHostKeyChecking=no",
+			"-o", "UserKnownHostsFile=/dev/null",
+			"-o", "LogLevel=ERROR",
+			"-o", "ConnectTimeout=10",
+			fmt.Sprintf("%s@%s", serverUser, serverName),
+			"sudo", "-S", "shutdown", "-h", "now")

-    return nil
+		// Capture stderr to log any error messages
+		stderr.Reset()
+		cmd.Stderr = &stderr
+		cmd.Stdin = bytes.NewBufferString(password + "\n")
+
+		err = cmd.Run()
+		if err == nil {
+			log.Println("SSH command executed successfully using sshpass")
+			return nil
+		}
+
+		log.Printf("sshpass method failed: %v - %s", err, stderr.String())
+	}
+
+	// Try direct SSH with password via stdin
+	log.Println("Trying direct SSH with password via stdin")
+	log.Printf("Password being used: %s", password)
+
+	cmd := exec.Command("ssh",
+		"-o", "StrictHostKeyChecking=no",
+		"-o", "UserKnownHostsFile=/dev/null",
+		"-o", "LogLevel=ERROR",
+		"-o", "ConnectTimeout=10",
+		fmt.Sprintf("%s@%s", serverUser, serverName),
+		"sudo", "-S", "shutdown", "-h", "now")
+
+	stderr.Reset()
+	cmd.Stderr = &stderr
+	cmd.Stdin = bytes.NewBufferString(password + "\n")
+
+	err = cmd.Run()
+	if err == nil {
+		log.Println("SSH command executed successfully using direct SSH")
+		return nil
+	}
+
+	log.Printf("SSH Error details: %s", stderr.String())
+
+	// Try a simpler shutdown command as a fallback
+	log.Println("Trying simpler shutdown command as fallback")
+	log.Printf("Password being used: %s", password)
+
+	cmd = exec.Command("ssh",
+		"-o", "StrictHostKeyChecking=no",
+		"-o", "UserKnownHostsFile=/dev/null",
+		"-o", "LogLevel=ERROR",
+		fmt.Sprintf("%s@%s", serverUser, serverName),
+		"sudo", "shutdown", "now")
+
+	stderr.Reset()
+	cmd.Stderr = &stderr
+	cmd.Stdin = bytes.NewBufferString(password + "\n")
+
+	err = cmd.Run()
+	if err != nil {
+		log.Printf("All shutdown attempts failed: %v - %s", err, stderr.String())
+		return fmt.Errorf("SSH command failed: %v - %s", err, stderr.String())
+	}
+
+	return nil
 }
Author	SHA1	Message	Date
Lorenzo Iovino	79864ace88	ci: adapt workflow for Forgejo Actions (replace gh-release with API call) All checks were successful Build and Release / Build multi-arch Raspberry Pi binaries (push) Successful in 10m14s Details	2026-02-07 17:48:19 +01:00
Lorenzo Iovino	a2140b5ea8	Added arm64 build	2025-12-15 16:26:57 +01:00
Lorenzo Iovino	fa9fe6095b	Initialize Go module	2025-09-05 13:49:48 +02:00