Fix git checkout for tag builds in Gitea Actions

- Add conditional logic to handle tag vs branch checkouts
- Tags don't exist on 'origin/tagname' so use direct checkout
- Branches can be checked out as 'origin/branchname'
- Fixes 'fatal: origin/v0.0.1 is not a commit' error

.gitea/workflows/release.yml

@@ -3,6 +3,7 @@ name: Build and Release
 on:
   push:
     branches:
+      - main
       - master
     tags:
       - 'v*'
@@ -12,129 +13,218 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        run: |
+          cd $GITHUB_WORKSPACE
+          git init
+          git remote add origin ${{ github.server_url }}/${{ github.repository }}.git
+          git fetch origin ${{ github.ref }}
+          if [[ "${{ github.ref }}" == refs/tags/* ]]; then
+            git checkout ${{ github.ref_name }}
+          else
+            git checkout -b ${{ github.ref_name }} origin/${{ github.ref_name }}
+          fi
 
       - name: Set up Go
-        uses: actions/setup-go@v4
+        run: |
-        with:
+          wget https://go.dev/dl/go1.24.4.linux-amd64.tar.gz
-          go-version: '1.24.4'
+          tar -C /usr/local -xzf go1.24.4.linux-amd64.tar.gz
+          export PATH=$PATH:/usr/local/go/bin
+          go version
 
       - name: Generate version
         id: version
         run: |
           if [[ "${{ github.ref }}" == refs/tags/* ]]; then
-            VERSION=${GITHUB_REF#refs/tags/}
+            VERSION=${{ github.ref_name }}
           else
             VERSION=dev-${{ github.sha }}
           fi
-          echo "version=${VERSION}" >> $GITHUB_OUTPUT
+          echo "version=${VERSION}" >> $GITHUB_ENV
 
       - name: Build all binaries
         run: |
+          export PATH=$PATH:/usr/local/go/bin
           mkdir -p bin
           
           # Generate templ first
           go run github.com/a-h/templ/cmd/templ@latest generate
           
           # Linux AMD64
+          echo "Building Linux AMD64..."
           GOOS=linux GOARCH=amd64 go build -ldflags="-w -s" -o bin/nerd-monitor-server-linux-amd64 ./cmd/server
           GOOS=linux GOARCH=amd64 go build -ldflags="-w -s" -o bin/nerd-monitor-agent-linux-amd64 ./cmd/agent
           
           # Linux ARM64
+          echo "Building Linux ARM64..."
           GOOS=linux GOARCH=arm64 go build -ldflags="-w -s" -o bin/nerd-monitor-server-linux-arm64 ./cmd/server
           GOOS=linux GOARCH=arm64 go build -ldflags="-w -s" -o bin/nerd-monitor-agent-linux-arm64 ./cmd/agent
           
           # macOS AMD64
+          echo "Building macOS AMD64..."
           GOOS=darwin GOARCH=amd64 go build -ldflags="-w -s" -o bin/nerd-monitor-server-darwin-amd64 ./cmd/server
           GOOS=darwin GOARCH=amd64 go build -ldflags="-w -s" -o bin/nerd-monitor-agent-darwin-amd64 ./cmd/agent
           
           # macOS ARM64
+          echo "Building macOS ARM64..."
           GOOS=darwin GOARCH=arm64 go build -ldflags="-w -s" -o bin/nerd-monitor-server-darwin-arm64 ./cmd/server
           GOOS=darwin GOARCH=arm64 go build -ldflags="-w -s" -o bin/nerd-monitor-agent-darwin-arm64 ./cmd/agent
           
           # Windows AMD64
+          echo "Building Windows AMD64..."
           GOOS=windows GOARCH=amd64 go build -ldflags="-w -s" -o bin/nerd-monitor-server-windows-amd64.exe ./cmd/server
           GOOS=windows GOARCH=amd64 go build -ldflags="-w -s" -o bin/nerd-monitor-agent-windows-amd64.exe ./cmd/agent
+          
+          echo "Build complete! Files:"
+          ls -lh bin/
 
       - name: Create checksums
         run: |
           cd bin
           sha256sum * > SHA256SUMS
           cd ..
+          echo "Checksums:"
+          cat bin/SHA256SUMS
 
-      - name: Upload artifacts
+      - name: Create Release and Upload
-        uses: actions/upload-artifact@v4
-        with:
-          name: binaries-${{ steps.version.outputs.version }}
-          path: bin/
-          retention-days: 30
-
-      - name: Create Release
-        if: startsWith(github.ref, 'refs/tags/')
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: Release ${{ github.ref }}
-          draft: false
-          prerelease: false
-
-      - name: Upload release assets
         if: startsWith(github.ref, 'refs/tags/')
         run: |
-          # This step uploads binaries to the release
+          export GITEA_TOKEN="${{ secrets.GITEA_TOKEN }}"
-          # Note: Gitea Actions may require additional configuration
+          export GITEA_URL="${{ github.server_url }}"
+          export REPO_OWNER="${{ github.repository_owner }}"
+          export REPO_NAME="${{ github.repository }}"
+          export REPO_NAME=${REPO_NAME#*/}
+          
+          TAG=${{ github.ref_name }}
+          
+          echo "Creating release for tag: $TAG"
+          echo "Repository: $REPO_OWNER/$REPO_NAME"
+          
+          # Get or create release
+          RELEASE_JSON=$(curl -s -X GET \
+            -H "Authorization: token $GITEA_TOKEN" \
+            "$GITEA_URL/api/v1/repos/$REPO_OWNER/$REPO_NAME/releases/tags/$TAG" 2>/dev/null || echo "{}")
+          
+          RELEASE_ID=$(echo "$RELEASE_JSON" | jq -r '.id // empty' 2>/dev/null)
+          
+          if [ -z "$RELEASE_ID" ]; then
+            echo "Creating new release..."
+            RELEASE_JSON=$(curl -s -X POST \
+              -H "Authorization: token $GITEA_TOKEN" \
+              -H "Content-Type: application/json" \
+              -d "{\"tag_name\":\"$TAG\",\"name\":\"Release $TAG\",\"draft\":false,\"prerelease\":false}" \
+              "$GITEA_URL/api/v1/repos/$REPO_OWNER/$REPO_NAME/releases")
+            RELEASE_ID=$(echo "$RELEASE_JSON" | jq -r '.id')
+            echo "Created release ID: $RELEASE_ID"
+          else
+            echo "Using existing release ID: $RELEASE_ID"
+          fi
+          
+          # Upload all binaries
+          echo "Uploading release artifacts..."
           for file in bin/*; do
             if [ -f "$file" ]; then
-              echo "Uploading $file to release"
+              filename=$(basename "$file")
+              echo "  Uploading: $filename"
+              
+              curl -s -X POST \
+                -H "Authorization: token $GITEA_TOKEN" \
+                -F "attachment=@$file" \
+                "$GITEA_URL/api/v1/repos/$REPO_OWNER/$REPO_NAME/releases/$RELEASE_ID/assets" > /dev/null
+              
+              if [ $? -eq 0 ]; then
+                echo "    ✓ $filename uploaded"
+              else
+                echo "    ✗ Failed to upload $filename"
+              fi
             fi
           done
+          
+          echo ""
+          echo "Release completed!"
+          echo "View at: $GITEA_URL/$REPO_OWNER/$REPO_NAME/releases/tag/$TAG"
 
   docker-build:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        run: |
+          cd $GITHUB_WORKSPACE
+          git init
+          git remote add origin ${{ github.server_url }}/${{ github.repository }}.git
+          git fetch origin ${{ github.ref }}
+          if [[ "${{ github.ref }}" == refs/tags/* ]]; then
+            git checkout ${{ github.ref_name }}
+          else
+            git checkout -b ${{ github.ref_name }} origin/${{ github.ref_name }}
+          fi
 
-      - name: Set up Docker Buildx
+      - name: Set up Docker
-        uses: docker/setup-buildx-action@v3
+        run: |
+          docker --version
+          which docker
 
       - name: Generate version
         id: version
         run: |
           if [[ "${{ github.ref }}" == refs/tags/* ]]; then
-            VERSION=${GITHUB_REF#refs/tags/}
+            VERSION=${{ github.ref_name }}
           else
             VERSION=dev-${{ github.sha }}
           fi
-          echo "version=${VERSION}" >> $GITHUB_OUTPUT
+          echo "version=${VERSION}" >> $GITHUB_ENV
 
-      - name: Build and push server image
+      - name: Build Docker images
-        uses: docker/build-push-action@v5
+        run: |
-        with:
+          mkdir -p /tmp/docker-images
-          context: .
+          
-          file: ./Dockerfile.server
+          echo "Building server image..."
-          push: false
+          docker build -t nerd-monitor-server:${{ env.version }} -f Dockerfile.server .
-          outputs: type=docker,dest=/tmp/nerd-monitor-server.tar
+          docker save nerd-monitor-server:${{ env.version }} -o /tmp/docker-images/nerd-monitor-server-${{ env.version }}.tar
-          tags: |
+          
-            nerd-monitor-server:latest
+          echo "Building agent image..."
-            nerd-monitor-server:${{ steps.version.outputs.version }}
+          docker build -t nerd-monitor-agent:${{ env.version }} -f Dockerfile.agent .
+          docker save nerd-monitor-agent:${{ env.version }} -o /tmp/docker-images/nerd-monitor-agent-${{ env.version }}.tar
+          
+          echo "Docker images built:"
+          ls -lh /tmp/docker-images/
 
-      - name: Build and push agent image
+      - name: Upload Docker images to release
-        uses: docker/build-push-action@v5
+        if: startsWith(github.ref, 'refs/tags/')
-        with:
+        run: |
-          context: .
+          export GITEA_TOKEN="${{ secrets.GITEA_TOKEN }}"
-          file: ./Dockerfile.agent
+          export GITEA_URL="${{ github.server_url }}"
-          push: false
+          export REPO_OWNER="${{ github.repository_owner }}"
-          outputs: type=docker,dest=/tmp/nerd-monitor-agent.tar
+          export REPO_NAME="${{ github.repository }}"
-          tags: |
+          export REPO_NAME=${REPO_NAME#*/}
-            nerd-monitor-agent:latest
+          
-            nerd-monitor-agent:${{ steps.version.outputs.version }}
+          TAG=${{ github.ref_name }}
-
+          
-      - name: Upload Docker images
+          # Get existing release
-        uses: actions/upload-artifact@v4
+          RELEASE_JSON=$(curl -s -X GET \
-        with:
+            -H "Authorization: token $GITEA_TOKEN" \
-          name: docker-images-${{ steps.version.outputs.version }}
+            "$GITEA_URL/api/v1/repos/$REPO_OWNER/$REPO_NAME/releases/tags/$TAG" 2>/dev/null || echo "{}")
-          path: /tmp/nerd-monitor-*.tar
+          
-          retention-days: 30
+          RELEASE_ID=$(echo "$RELEASE_JSON" | jq -r '.id // empty' 2>/dev/null)
+          
+          if [ -z "$RELEASE_ID" ]; then
+            echo "Release not found, skipping Docker image upload"
+          else
+            echo "Uploading Docker images to release $RELEASE_ID..."
+            for file in /tmp/docker-images/*; do
+              if [ -f "$file" ]; then
+                filename=$(basename "$file")
+                echo "  Uploading: $filename"
+                
+                curl -s -X POST \
+                  -H "Authorization: token $GITEA_TOKEN" \
+                  -F "attachment=@$file" \
+                  "$GITEA_URL/api/v1/repos/$REPO_OWNER/$REPO_NAME/releases/$RELEASE_ID/assets" > /dev/null
+                
+                if [ $? -eq 0 ]; then
+                  echo "    ✓ $filename uploaded"
+                else
+                  echo "    ✗ Failed to upload $filename"
+                fi
+              fi
+            done
+          fi

GITEA_SETUP.md

@@ -0,0 +1,151 @@
+# Gitea Actions Setup - Server Configuration Checklist
+
+This document outlines the changes needed on your Gitea server to make the CI/CD pipeline work.
+
+## What You Need to Do
+
+### 1. Add GITEA_TOKEN Secret to Repository
+
+1. **Log into Gitea** with your user account
+2. **Navigate to** your nerd-monitor repository
+3. **Go to Settings → Secrets**
+4. **Create a new secret**:
+   - Name: `GITEA_TOKEN`
+   - Value: [Your Gitea API token - see below for how to create]
+5. **Save the secret**
+
+### 2. Create an API Token (if you haven't already)
+
+1. **Log into Gitea** with your user account
+2. **Go to Settings → Applications**
+3. **Click "Generate New Token"**
+4. **Fill in the form**:
+   - Token Name: `release-automation`
+   - Scopes: Select at least `repo` (full repository access)
+5. **Click "Generate"**
+6. **Copy the token immediately** (you won't see it again)
+7. **Use this token** for the secret in step 1
+
+### 3. Verify Gitea Actions is Enabled (Server Admin)
+
+These steps require SSH access to your Gitea server:
+
+```bash
+# SSH into your Gitea server
+ssh user@your-gitea-server
+
+# Edit the Gitea configuration
+sudo vi /etc/gitea/app.ini
+
+# Verify or add this section:
+[actions]
+ENABLED = true
+
+# Save and exit (Esc, :wq, Enter)
+
+# Restart Gitea for changes to take effect
+sudo systemctl restart gitea
+```
+
+### 4. Verify Your Runner is Online (Server Admin)
+
+1. **Log into Gitea** as admin
+2. **Go to Administration → Actions → Runners**
+3. **Verify** at least one runner is listed and shows as "Online" or "Idle"
+4. If no runners:
+   - You need to set up a Gitea Actions runner on a machine with Docker and Go
+   - See "Setting Up a Runner" below
+
+## Setting Up a Runner (if needed)
+
+If you don't have any runners yet, you need to set one up. This can be on the Gitea server itself or any machine with Docker/Go.
+
+### Quick Runner Setup
+
+1. **On your Gitea server or runner machine**:
+
+```bash
+# Download the Gitea Actions runner
+wget https://github.com/gitea/act_runner/releases/download/v0.6.10/act_runner-0.6.10-linux-amd64
+chmod +x act_runner-0.6.10-linux-amd64
+
+# Register the runner with your Gitea instance
+./act_runner-0.6.10-linux-amd64 register \
+  --instance https://git.nerdnest.dev \
+  --token <your-runner-token>
+
+# Run the runner in the background
+./act_runner-0.6.10-linux-amd64 daemon &
+```
+
+To get a runner token:
+1. Log into Gitea as **admin**
+2. Go to **Administration → Actions → Runners**
+3. Click **Create new runner**
+4. Follow the registration steps
+
+## Testing the Setup
+
+Once everything is configured:
+
+1. **Push a test tag**:
+```bash
+git tag -a v0.0.1-test -m "Test release"
+git push origin v0.0.1-test
+```
+
+2. **Monitor the build**:
+   - Go to Actions tab
+   - You should see the workflow running
+   - Check logs for any errors
+
+3. **Verify the release**:
+   - Go to Releases tab
+   - You should see a new release with binaries and checksums
+
+## Troubleshooting
+
+### "Action not found" error
+- Make sure Gitea Actions is enabled
+- Restart Gitea if you just enabled it: `sudo systemctl restart gitea`
+
+### No runners available
+- Runner must be registered: Administration → Actions → Runners
+- Runner machine must have Docker and Go installed
+- Check if runner is online in the UI
+
+### "GITEA_TOKEN" not found
+- Make sure the secret is named exactly `GITEA_TOKEN` (case-sensitive)
+- Go to Settings → Secrets and verify it's there
+- If it's there, try re-running the workflow
+
+### Build fails with permission denied
+- Make sure the runner has permission to run Docker commands
+- On the runner machine: `sudo usermod -aG docker $USER`
+- Logout and log back in for the group change to take effect
+
+## What Happens Next
+
+Once you've set everything up:
+
+1. **Every push to main/master** triggers the build job:
+   - Compiles all platform binaries
+   - Builds Docker images
+   - Uploads artifacts as build artifacts
+
+2. **Every git tag push** (e.g., `v1.0.0`) triggers the full release:
+   - Does all of the above
+   - Creates a Gitea Release
+   - Uploads all binaries and Docker images to the release
+   - Generates SHA256 checksums
+
+3. **Releases are available in**:
+   - Repository Releases tab in Gitea
+   - Binaries ready for download
+   - Docker images ready for import
+
+## Support
+
+- Gitea Actions Docs: https://docs.gitea.io/en-us/actions/
+- Act Runner Docs: https://gitea.com/gitea/act_runner
+- For issues with the workflow itself, check the Actions tab logs

RELEASE.md

@@ -40,42 +40,58 @@ The Gitea Actions workflow is defined in `.gitea/workflows/release.yml`
 - `build`: Compiles all platform binaries and generates checksums
 - `docker-build`: Builds Docker images for server and agent
 
-## Creating a Release
+### Creating a Release
 
-### Option 1: Automatic Release (Recommended)
+#### Step 1: Create and Push a Tag
 
-1. Create a new tag:
 ```bash
+# Create an annotated tag
 git tag -a v1.0.0 -m "Release version 1.0.0"
+
+# Push the tag to Gitea
 git push origin v1.0.0
 ```
 
-2. Gitea Actions will automatically:
+#### Step 2: Monitor the Workflow
-   - Build all binaries
-   - Create a release in Gitea
-   - Upload all artifacts
 
-3. View the release in Gitea: `Releases` tab on your repository
+1. Go to your repository on Gitea
+2. Click the **Actions** tab
+3. You'll see the workflow running:
+   - `build` job: Compiles all binaries (5-10 minutes)
+   - `docker-build` job: Builds Docker images (5-10 minutes)
 
-### Option 2: Manual Release Upload
+#### Step 3: Verify the Release
 
-If you need to manually upload binaries to Gitea:
+Once the workflow completes:
 
-```bash
+1. Go to the **Releases** tab
-# Set your Gitea token (create one in Gitea Settings → Applications → Generate Token)
+2. You'll see a new release with:
-export GITEA_TOKEN=your_token_here
+   - All platform binaries (Linux, macOS, Windows)
+   - SHA256SUMS file with checksums
+   - Docker image files (.tar)
 
-# Build all binaries
+### What Gets Built and Released
-make build-all
 
-# Upload to release
+When you push a tag, the workflow automatically:
-./scripts/upload-release.sh v1.0.0
-```
 
-Environment variables (optional):
+**Binaries** (10 files total):
-- `GITEA_URL`: Gitea server URL (default: `https://git.nerdnest.dev`)
+- `nerd-monitor-server-linux-amd64` - Server for Linux x86_64
-- `REPO_OWNER`: Repository owner (default: `ducky`)
+- `nerd-monitor-server-linux-arm64` - Server for Linux ARM64 (Raspberry Pi, etc.)
-- `REPO_NAME`: Repository name (default: `nerd-monitor`)
+- `nerd-monitor-server-darwin-amd64` - Server for macOS Intel
+- `nerd-monitor-server-darwin-arm64` - Server for macOS Apple Silicon
+- `nerd-monitor-server-windows-amd64.exe` - Server for Windows
+- `nerd-monitor-agent-linux-amd64` - Agent for Linux x86_64
+- `nerd-monitor-agent-linux-arm64` - Agent for Linux ARM64
+- `nerd-monitor-agent-darwin-amd64` - Agent for macOS Intel
+- `nerd-monitor-agent-darwin-arm64` - Agent for macOS Apple Silicon
+- `nerd-monitor-agent-windows-amd64.exe` - Agent for Windows
+
+**Checksums**:
+- `SHA256SUMS` - SHA256 checksums for all binaries (for verification)
+
+**Docker Images**:
+- `nerd-monitor-server-v1.0.0.tar` - Server Docker image (can be imported)
+- `nerd-monitor-agent-v1.0.0.tar` - Agent Docker image (can be imported)
 
 ## Local Building
 
@@ -112,33 +128,64 @@ docker run nerd-monitor-agent --server your-server:8080
 
 ## Gitea Configuration
 
-### Enable Gitea Actions
+### Prerequisites
 
-1. SSH into your Gitea server
+Before the CI/CD pipeline can create releases automatically, you need to:
-2. Edit `app.ini`:
+
-```ini
+1. **Ensure Gitea Actions is enabled** on your Gitea server
+2. **Create a Gitea API Token** with release permissions
+3. **Add the token as an Actions secret** in your repository
+
+### Setup Instructions
+
+#### 1. Enable Gitea Actions (Server Admin)
+
+SSH into your Gitea server and verify Actions is enabled:
+
+```bash
+# Edit the Gitea configuration
+sudo vi /etc/gitea/app.ini
+
+# Add or verify:
 [actions]
 ENABLED = true
 ```
-3. Restart Gitea:
+
+Then restart Gitea:
 ```bash
-systemctl restart gitea
+sudo systemctl restart gitea
 ```
 
-### Create an API Token (for manual uploads)
+#### 2. Create an API Token
 
-1. Go to Settings → Applications
+1. Log in to Gitea with your user account
-2. Click "Generate New Token"
+2. Go to **Settings** → **Applications**
-3. Name it (e.g., "Release Upload")
+3. Click **Generate New Token**
-4. Give it `repo` permissions
+4. Fill in:
-5. Copy the token
+   - **Token Name**: `release-automation` (or any descriptive name)
+   - **Scopes**: Select `repo` (full repository access)
+5. Click **Generate Token**
+6. **Copy the token** (you won't be able to see it again)
 
-Use it with the upload script:
+#### 3. Add Token as Repository Secret
-```bash
-./scripts/upload-release.sh v1.0.0 <your_token>
-```
 
-## Release Files
+1. Go to your repository on Gitea
+2. Navigate to **Settings** → **Secrets**
+3. Click **Add Secret**
+4. Fill in:
+   - **Secret Name**: `GITEA_TOKEN`
+   - **Secret Value**: Paste the token you copied
+5. Click **Save**
+
+Now the workflow will be able to create releases automatically!
+
+### Workflow Configuration
+
+The Gitea Actions workflow is defined in `.gitea/workflows/release.yml`
+
+### Trigger Events
+- Push to `master` or `main` branch (builds only, no release)
+- Push of git tags (e.g., `v1.0.0`) - triggers full release with uploads
 
 Each release includes:
 
@@ -173,20 +220,76 @@ If you want to use Coolify for deployment:
 
 ## Troubleshooting
 
-### Actions not running
+### Workflow Not Triggering
-- Ensure Gitea Actions is enabled on your server
-- Check that your runner is available (`Settings → Actions`)
-- Review action logs in the `Actions` tab
 
-### Release not created
+**Problem**: I pushed a tag but the workflow didn't start
-- Ensure the tag format matches semantic versioning (v1.0.0)
-- Check workflow logs for build errors
-- Verify Go 1.24.4 is available in the runner environment
 
-### Docker images not building
+**Solutions**:
-- Ensure Docker/Buildx is available in the runner
+1. Check that the tag is pushed: `git push origin v1.0.0`
-- Check the Dockerfile syntax
+2. Verify Gitea Actions is enabled: Settings → Actions → Status should show "Enabled"
-- Review build logs in the Actions tab
+3. Check Actions tab for any error messages
+4. Ensure your runner is online: Settings → Runners
+
+### Token Authentication Failed
+
+**Problem**: `"message":"Unauthorized"` or token-related errors in the logs
+
+**Solutions**:
+1. Verify the `GITEA_TOKEN` secret is set correctly: Repository → Settings → Secrets
+2. Ensure the token has `repo` scope permissions
+3. Token should not be expired - regenerate if needed
+4. Double-check there are no extra spaces in the token
+
+### Build Fails with "Go not found"
+
+**Problem**: Workflow fails when trying to build, says Go is not available
+
+**Solutions**:
+1. This is usually a temporary issue - runner environment might not have been fully initialized
+2. Retry the workflow: Go to Actions tab → Click the failed workflow → Click "Re-run jobs"
+3. Check if the runner has enough disk space: `df -h` on the runner machine
+
+### Binaries Not Uploaded to Release
+
+**Problem**: Workflow completes but binaries don't appear in the release
+
+**Solutions**:
+1. Check the workflow logs: Actions tab → Click the workflow → View logs
+2. Look for "Uploading" messages and any error messages
+3. Verify the release was created: Go to Releases tab
+4. Check that `GITEA_TOKEN` secret is still valid (tokens can expire)
+
+### Docker Image Build Fails
+
+**Problem**: `docker-build` job fails
+
+**Solutions**:
+1. Verify Docker is installed on the runner: SSH to runner and run `docker --version`
+2. Check if the Dockerfile has syntax errors: `docker build -f Dockerfile.server .`
+3. Ensure runner has enough disk space for building: `docker system df`
+4. Check Docker daemon is running: `sudo systemctl status docker`
+
+### How to Check Workflow Logs
+
+1. Go to your Gitea repository
+2. Click the **Actions** tab
+3. Click on the workflow run (should show the tag name)
+4. Click on the job that failed (`build` or `docker-build`)
+5. Scroll through the log to find error messages
+6. Look for red `❌` marks indicating failures
+
+### Manual Trigger for Testing
+
+If you want to test the workflow without creating a full release:
+
+```bash
+# Push to main/master branch (triggers build only, no release)
+git push origin main
+
+# Then push a tag when you're ready (triggers full release)
+git tag -a v1.0.0 -m "Release"
+git push origin v1.0.0
+```
 
 ## Additional Resources
 
@@ -194,3 +297,4 @@ If you want to use Coolify for deployment:
 - [Project README](./README.md)
 - [Quick Start Guide](./QUICKSTART.md)
 - [Agent Guidelines](./AGENTS.md)
+- [Docker Compose Guide](./DOCKER_COMPOSE.md)