Fix Alpine Linux addgroup/adduser syntax for non-root user creation

Fix Docker Compose and Dockerfile issues: remove image pull, fix entrypoint permissions
Fix wget --post-file usage with temporary files for API calls
2025-12-20 06:45:21 +00:00 · 2025-12-20 06:36:20 +00:00 · 2025-12-20 06:31:33 +00:00 · 2025-12-20 06:31:02 +00:00 · 2025-12-20 06:28:25 +00:00 · 2025-12-20 06:24:56 +00:00
6 changed files with 168 additions and 218 deletions
--- a/.gitea/workflows/release.yml
+++ b/.gitea/workflows/release.yml
@@ -17,10 +17,14 @@ jobs:
          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 }}
+            # For tags, fetch the specific tag and checkout the commit it points to
+            git fetch origin ${{ github.ref }}:refs/tags/${{ github.ref_name }}
+            git checkout refs/tags/${{ github.ref_name }}
          else
+            # For branches, fetch and checkout with tracking
+            git fetch origin ${{ github.ref_name }}:refs/remotes/origin/${{ github.ref_name }}
            git checkout -b ${{ github.ref_name }} origin/${{ github.ref_name }}
          fi

@@ -99,26 +103,32 @@ jobs:
          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 "{}")
+          # Create release using Gitea API with wget
+          echo "Creating new release..."
          
-          RELEASE_ID=$(echo "$RELEASE_JSON" | jq -r '.id // empty' 2>/dev/null)
+          # Create JSON payload in a temp file
+          cat > /tmp/release.json << 'PAYLOAD'
+          {"tag_name":"TAG_PLACEHOLDER","name":"Release TAG_PLACEHOLDER","draft":false,"prerelease":false}
+          PAYLOAD
+          sed -i "s/TAG_PLACEHOLDER/$TAG/g" /tmp/release.json
+          
+          RESPONSE=$(wget --post-file=/tmp/release.json \
+            --header="Authorization: token $GITEA_TOKEN" \
+            --header="Content-Type: application/json" \
+            -O - -q \
+            "$GITEA_URL/api/v1/repos/$REPO_OWNER/$REPO_NAME/releases")
+          
+          # Extract release ID using grep
+          RELEASE_ID=$(echo "$RESPONSE" | grep -o '"id":[0-9]*' | head -1 | grep -o '[0-9]*')
          
          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"
+            echo "Failed to create release. Response:"
+            echo "$RESPONSE"
+            exit 1
          fi
          
+          echo "Created release ID: $RELEASE_ID"
+          
          # Upload all binaries
          echo "Uploading release artifacts..."
          for file in bin/*; do
@@ -126,15 +136,18 @@ jobs:
              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
+              # Upload binary file to Gitea API
+              UPLOAD_RESPONSE=$(wget --post-file="$file" \
+                --header="Authorization: token $GITEA_TOKEN" \
+                --header="Content-Type: application/octet-stream" \
+                -O - -q \
+                "$GITEA_URL/api/v1/repos/$REPO_OWNER/$REPO_NAME/releases/$RELEASE_ID/assets?name=$filename" 2>&1)
              
-              if [ $? -eq 0 ]; then
+              if echo "$UPLOAD_RESPONSE" | grep -q '"id"'; then
                echo "    ✓ $filename uploaded"
              else
                echo "    ✗ Failed to upload $filename"
+                echo "Response: $UPLOAD_RESPONSE"
              fi
            fi
          done
@@ -142,89 +155,3 @@ jobs:
          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
-        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
-        run: |
-          docker --version
-          which docker
-
-      - name: Generate version
-        id: version
-        run: |
-          if [[ "${{ github.ref }}" == refs/tags/* ]]; then
-            VERSION=${{ github.ref_name }}
-          else
-            VERSION=dev-${{ github.sha }}
-          fi
-          echo "version=${VERSION}" >> $GITHUB_ENV
-
-      - name: Build Docker images
-        run: |
-          mkdir -p /tmp/docker-images
-          
-          echo "Building server image..."
-          docker build -t nerd-monitor-server:${{ env.version }} -f Dockerfile.server .
-          docker save nerd-monitor-server:${{ env.version }} -o /tmp/docker-images/nerd-monitor-server-${{ env.version }}.tar
-          
-          echo "Building agent image..."
-          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: Upload Docker images to release
-        if: startsWith(github.ref, 'refs/tags/')
-        run: |
-          export GITEA_TOKEN="${{ secrets.GITEA_TOKEN }}"
-          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 }}
-          
-          # Get existing 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 "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
--- a/Dockerfile.agent
+++ b/Dockerfile.agent
@@ -25,21 +25,21 @@ WORKDIR /app

 COPY --from=builder /app/nerd-monitor-agent .

-# Create non-root user
-RUN addgroup -D appgroup && adduser -D appuser -G appgroup
-USER appuser
+# Create entrypoint script BEFORE switching users
+RUN echo '#!/bin/sh' > /app/entrypoint.sh && \
+    echo 'SERVER=${SERVER:-localhost:8080}' >> /app/entrypoint.sh && \
+    echo 'INTERVAL=${INTERVAL:-15s}' >> /app/entrypoint.sh && \
+    echo 'AGENT_ID=${AGENT_ID:-}' >> /app/entrypoint.sh && \
+    echo 'if [ -z "$AGENT_ID" ]; then' >> /app/entrypoint.sh && \
+    echo '  exec ./nerd-monitor-agent --server "$SERVER" --interval "$INTERVAL"' >> /app/entrypoint.sh && \
+    echo 'else' >> /app/entrypoint.sh && \
+    echo '  exec ./nerd-monitor-agent --server "$SERVER" --interval "$INTERVAL" --id "$AGENT_ID"' >> /app/entrypoint.sh && \
+    echo 'fi' >> /app/entrypoint.sh && \
+    chmod +x /app/entrypoint.sh

-# Create entrypoint script to handle environment variables
-RUN echo '#!/bin/sh\n\
-SERVER=${SERVER:-localhost:8080}\n\
-INTERVAL=${INTERVAL:-15s}\n\
-AGENT_ID=${AGENT_ID:-}\n\
-if [ -z "$AGENT_ID" ]; then\n\
-  exec ./nerd-monitor-agent --server "$SERVER" --interval "$INTERVAL"\n\
-else\n\
-  exec ./nerd-monitor-agent --server "$SERVER" --interval "$INTERVAL" --id "$AGENT_ID"\n\
-fi\n\
-' > /app/entrypoint.sh && chmod +x /app/entrypoint.sh
+# Create non-root user
+RUN addgroup -g 1000 appgroup && adduser -D -u 1000 -G appgroup appuser
+USER appuser

 # Run the agent
 ENTRYPOINT ["/app/entrypoint.sh"]
--- a/Dockerfile.server
+++ b/Dockerfile.server
@@ -32,8 +32,17 @@ RUN apk add --no-cache ca-certificates
 # Copy binary from builder
 COPY --from=builder /app/nerd-monitor-server .

+# Create entrypoint script BEFORE switching users
+RUN echo '#!/bin/sh' > /app/entrypoint.sh && \
+    echo 'ADDR=${ADDR:-0.0.0.0}' >> /app/entrypoint.sh && \
+    echo 'PORT=${PORT:-8080}' >> /app/entrypoint.sh && \
+    echo 'USERNAME=${USERNAME:-admin}' >> /app/entrypoint.sh && \
+    echo 'PASSWORD=${PASSWORD:-admin}' >> /app/entrypoint.sh && \
+    echo 'exec ./nerd-monitor-server -addr "$ADDR" -port "$PORT" -username "$USERNAME" -password "$PASSWORD"' >> /app/entrypoint.sh && \
+    chmod +x /app/entrypoint.sh
+
 # Create non-root user
-RUN addgroup -D appgroup && adduser -D appuser -G appgroup
+RUN addgroup -g 1000 appgroup && adduser -D -u 1000 -G appgroup appuser
 USER appuser

 # Expose port
@@ -43,14 +52,5 @@ EXPOSE 8080
 HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD wget --quiet --tries=1 --spider http://localhost:8080/login || exit 1

-# Create entrypoint script to handle environment variables
-RUN echo '#!/bin/sh\n\
-ADDR=${ADDR:-0.0.0.0}\n\
-PORT=${PORT:-8080}\n\
-USERNAME=${USERNAME:-admin}\n\
-PASSWORD=${PASSWORD:-admin}\n\
-exec ./nerd-monitor-server -addr "$ADDR" -port "$PORT" -username "$USERNAME" -password "$PASSWORD"\n\
-' > /app/entrypoint.sh && chmod +x /app/entrypoint.sh
-
 # Run the server
 ENTRYPOINT ["/app/entrypoint.sh"]
--- a/GITEA_SETUP.md
+++ b/GITEA_SETUP.md
@@ -58,7 +58,7 @@ sudo systemctl restart gitea

 ## 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.
+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 and Go.

 ### Quick Runner Setup

@@ -84,34 +84,66 @@ To get a runner token:
 3. Click **Create new runner**
 4. Follow the registration steps

-## Testing the Setup
+### Installing Docker on the Runner (Optional)

-Once everything is configured:
+Docker is **not required** for the CI/CD pipeline. Binary builds work without Docker.
+
+If you want to manually build Docker images:

-1. **Push a test tag**:
 ```bash
-git tag -a v0.0.1-test -m "Test release"
-git push origin v0.0.1-test
+# Build server image
+docker build -t nerd-monitor-server -f Dockerfile.server .
+
+# Build agent image
+docker build -t nerd-monitor-agent -f Dockerfile.agent .
+
+# Or use docker-compose for both
+docker-compose build
+docker-compose up
 ```

-2. **Monitor the build**:
-   - Go to Actions tab
-   - You should see the workflow running
-   - Check logs for any errors
+## What Happens Next

-3. **Verify the release**:
-   - Go to Releases tab
-   - You should see a new release with binaries and checksums
+Once you've set everything up:
+
+1. **Every push to main/master** triggers the build job:
+   - Compiles all platform binaries (Linux, macOS, Windows)
+   - Creates SHA256 checksums
+   - Artifacts available for 30 days
+
+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 checksums to the release (permanent storage)
+
+3. **Releases are available in**:
+   - Repository Releases tab in Gitea
+   - All binaries ready for download
+   - SHA256SUMS file for verification
+
+Note: Docker images are not built automatically. To build Docker images manually, use:
+```bash
+docker build -t nerd-monitor-server -f Dockerfile.server .
+docker build -t nerd-monitor-agent -f Dockerfile.agent .
+# Or use docker-compose: docker-compose build
+```

 ## Troubleshooting

+### "docker: command not found" in workflow
+- Docker support is not required - the workflow builds binaries without it
+- Binary builds will always succeed
+- Docker images must be built manually using: `docker build -f Dockerfile.server .`
+- See QUICKSTART.md or DOCKER_COMPOSE.md for manual Docker build instructions
+
 ### "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
+- Runner machine must have Go installed (1.24.4 or later)
+- Docker is optional (for building Docker images)
 - Check if runner is online in the UI

 ### "GITEA_TOKEN" not found
@@ -119,33 +151,14 @@ git push origin v0.0.1-test
 - 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
+### Build fails with permission denied (Docker)
+- Make sure the runner user 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
+- Docker Installation: https://docs.docker.com/install/
 - For issues with the workflow itself, check the Actions tab logs
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -2,7 +2,7 @@

 ## Overview

-This project uses **Gitea Actions** to automatically build and release binaries and Docker images when you push to the `master` branch or create a new tag.
+This project uses **Gitea Actions** to automatically build and release cross-platform binaries when you push to the `master` branch or create a new tag.

 ## Automatic Release Pipeline

@@ -11,13 +11,12 @@ This project uses **Gitea Actions** to automatically build and release binaries
 1. **Master Branch Push**: When you push to `master`, the workflow:
   - Builds all platform binaries (Linux/macOS/Windows, amd64/arm64)
   - Generates checksums (SHA256)
-   - Uploads artifacts for 30 days
-   - Builds Docker images (server & agent)
+   - Binaries are available as build artifacts for 30 days

 2. **Tag Creation**: When you create a tag (e.g., `v1.0.0`), the workflow:
   - Does all of the above
-   - Creates a GitHub Release
-   - Uploads all binaries and Docker images to the release
+   - Creates a Gitea Release
+   - Uploads all binaries and checksums to the release (permanent storage)

 ### Supported Platforms

@@ -26,19 +25,32 @@ Binaries are built for:
 - **macOS**: amd64 (Intel), arm64 (Apple Silicon)
 - **Windows**: amd64

-Docker images are built for Linux containers.
+### What Gets Built and Released
+
+When you push a tag, the workflow automatically creates:
+
+**Binaries** (10 files total):
+- `nerd-monitor-server-linux-amd64` - Server for Linux x86_64
+- `nerd-monitor-server-linux-arm64` - Server for Linux ARM64 (Raspberry Pi, etc.)
+- `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)

 ## Workflow Configuration

 The Gitea Actions workflow is defined in `.gitea/workflows/release.yml`

 ### Trigger Events
- Push to `master` branch
- Push of git tags (e.g., `v1.0.0`)
-
-### Jobs
- `build`: Compiles all platform binaries and generates checksums
- `docker-build`: Builds Docker images for server and agent
+- Push to `master` or `main` branch (builds only, no release)
+- Push of git tags (e.g., `v1.0.0`) - triggers full release with uploads

 ### Creating a Release

@@ -89,10 +101,6 @@ When you push a tag, the workflow automatically:
 **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

 You can also build binaries locally:
@@ -110,21 +118,25 @@ make clean

 Binaries are created in the `bin/` directory.

-## Docker Images
+## Docker Images (Manual Build)

-Two Docker images are built:
+Docker images are available but not built automatically by CI/CD. To build them manually:

-### Server Image
 ```bash
-docker pull nerd-monitor-server:latest
-docker run -p 8080:8080 nerd-monitor-server
+# Build server image
+docker build -t nerd-monitor-server:latest -f Dockerfile.server .
+
+# Build agent image
+docker build -t nerd-monitor-agent:latest -f Dockerfile.agent .
+
+# Or use Docker Compose
+docker-compose build
+
+# Or use Docker Compose to run both
+docker-compose up
 ```

-### Agent Image
-```bash
-docker pull nerd-monitor-agent:latest
-docker run nerd-monitor-agent --server your-server:8080
-```
+See `DOCKER_COMPOSE.md` and `QUICKSTART.md` for detailed instructions.

 ## Gitea Configuration

@@ -205,18 +217,30 @@ nerd-monitor-agent-windows-amd64.exe
 SHA256SUMS (checksums for all binaries)
 ```

-## Coolify Integration
+## Deployment Options

-If you want to use Coolify for deployment:
+### Option 1: Use Pre-Built Binaries (Recommended)
+Download the native binaries from the Releases tab and run directly:
+- Smallest footprint
+- No Docker required
+- Easiest to deploy to existing machines

-1. **For Server Deployment**:
-   - Use `Dockerfile.server` as the build context
-   - Coolify will auto-build on `master` branch pushes
-   - Deploy the server container to Coolify
+### Option 2: Use Docker (Manual Build)
+Build Docker images manually and deploy:
+```bash
+docker build -t nerd-monitor-server:latest -f Dockerfile.server .
+docker run -p 8080:8080 nerd-monitor-server:latest
+```

-2. **For Agent Deployment**:
-   - Use `Dockerfile.agent` as the build context
-   - Deploy the agent container to machines that need monitoring
+See `docker-compose.yml` for running both server and agent together.
+
+### Option 3: Use Docker Compose
+For quick development/testing with both server and agent:
+```bash
+docker-compose up
+```
+
+See `DOCKER_COMPOSE.md` and `QUICKSTART.md` for details.

 ## Troubleshooting

@@ -259,22 +283,12 @@ If you want to use Coolify for deployment:
 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`)
+4. Click on the `build` job
 5. Scroll through the log to find error messages
 6. Look for red `❌` marks indicating failures

--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1,5 +1,3 @@
-version: '3.8'
-
 # ============================================================================
 # Nerd Monitor Docker Compose Configuration
 # ============================================================================
@@ -40,7 +38,6 @@ services:
      context: .
      dockerfile: Dockerfile.server
    container_name: nerd-monitor-server
-    image: nerd-monitor-server:latest
    ports:
      - "8080:8080"
    environment:
@@ -82,7 +79,6 @@ services:
    build:
      context: .
      dockerfile: Dockerfile.agent
-    image: nerd-monitor-agent:latest
    environment:
      # Agent configuration
      SERVER: "server:8080"        # Connect to the server service
Author	SHA1	Message	Date
Ducky SSH User	0a37b04506	Fix Alpine Linux addgroup/adduser syntax for non-root user creation All checks were successful Build and Release / build (push) Successful in 12s Details	2025-12-20 06:45:21 +00:00
Ducky SSH User	a5a683d1de	Fix Docker Compose and Dockerfile issues: remove image pull, fix entrypoint permissions	2025-12-20 06:36:20 +00:00
Ducky SSH User	e0b8f8650b	Fix wget --post-file usage with temporary files for API calls All checks were successful Build and Release / build (push) Successful in 11s Details	2025-12-20 06:31:33 +00:00
Ducky SSH User	3a7b5a0f9a	Replace curl with wget in CI/CD workflow for Gitea runner compatibility	2025-12-20 06:31:02 +00:00
Ducky SSH User	999a595b9c	Remove jq dependency from release workflow Some checks failed Build and Release / build (push) Failing after 12s Details - Replace jq with grep for parsing JSON responses - Use curl -w to capture HTTP response codes - Improve error handling and logging - Check HTTP response codes for upload success - Should work on runners without jq installed - Fixes 'command not found' error on release creation	2025-12-20 06:28:25 +00:00
Ducky SSH User	e6f705486d	Fix git tag checkout in Gitea Actions workflow Some checks failed Build and Release / build (push) Failing after 10s Details - For tags: fetch with explicit ref mapping to refs/tags/ - For branches: fetch with explicit ref mapping to refs/remotes/origin/ - Properly checkout tag refs using refs/tags/ path - Fixes 'pathspec did not match any file(s)' error on tag builds	2025-12-20 06:24:56 +00:00
Ducky SSH User	66734923cb	Update GITEA_SETUP.md for binary-only CI/CD pipeline Some checks failed Build and Release / build (push) Failing after 1s Details - Clarify Docker is not required for CI/CD - Note that Docker images are built manually - Simplify troubleshooting section - Remove Docker setup instructions from setup guide - Link to manual Docker build documentation	2025-12-20 06:21:37 +00:00
Ducky SSH User	48d2d7f83d	Update RELEASE.md to reflect binary-only CI/CD pipeline - Remove references to Docker image CI/CD builds - Clarify Docker images are built manually or with docker-compose - Simplify deployment options (binaries, Docker, Docker Compose) - Update troubleshooting to focus on binary releases - Remove Docker-specific troubleshooting steps - Keep Dockerfiles for manual builds	2025-12-20 06:21:18 +00:00
Ducky SSH User	444bda7263	Remove Docker-specific runner documentation - Remove GITEA_RUNNER_DOCKER.md (no longer needed) - Docker builds removed from CI/CD pipeline - Dockerfiles and docker-compose remain for manual builds	2025-12-20 06:20:35 +00:00
Ducky SSH User	99fc1a28ad	Simplify CI/CD pipeline to focus on binary releases only - Remove docker-build job entirely - Keep focus on cross-platform binary builds (Linux, macOS, Windows) - Generate SHA256 checksums for all binaries - Upload binaries and checksums to Gitea releases - Keep Dockerfiles and docker-compose for manual builds - Much simpler and more reliable workflow	2025-12-20 06:20:32 +00:00
Ducky SSH User	2075cd2901	Fix Docker builds in Gitea runner with proper Docker-in-Docker detection - Use 'docker info' instead of 'command -v docker' for reliable detection - Add 30-second wait for Docker daemon startup (for DinD startup delay) - Improve Docker build step with better error handling - Build Docker images when available, skip gracefully if not - Add comprehensive GITEA_RUNNER_DOCKER.md setup guide - Document Docker socket mounting for runners - Include troubleshooting and complete docker-compose example	2025-12-20 06:16:10 +00:00
Ducky SSH User	f4ec33fe53	Update GITEA_SETUP.md with optional Docker configuration - Document Docker installation on runner for image builds - Clarify that Docker is optional (not required for binary builds) - Add instructions for running the runner user with Docker permissions - Update troubleshooting section with Docker-specific guidance - Explain graceful handling when Docker is not available - Add Docker installation link in support section	2025-12-20 06:13:53 +00:00
Ducky SSH User	3080cb1e87	Make Docker build optional in Gitea Actions workflow - Check if Docker is available before attempting to use it - Skip Docker image builds gracefully if Docker is not installed - Provide helpful instructions for enabling Docker support - Add error handling for Docker build failures - Allow workflow to succeed even without Docker - Binary builds will still complete successfully	2025-12-20 06:13:34 +00:00