feat: add improvements to the server and docker image (#1)

* docs(readme): fix the example on the readme file

* feat(server): add a server package to make the app more testable

* docs(server): add doc comments to functions

* test(server): add a test function to validate the behavior of the proxy server

* refactor(server): use env variables instead of flags

* docs(readme): update the running command

* build(docker): add a dockerfile to run a container

* build(makefile): add a makefile

* ci(github): add a github action workflow to ship the container to the github registry

* feat(server): call and run the server package on the server command

* feat(middlewares): add middleware to log the site of interest

* docs(readme): expand the content of the readme file to explain how to use the project

Author: danvergara

.dockerignore

@@ -0,0 +1,5 @@
+.git
+LICENSE
+Makefile
+README.md
+bin/

.github/workflows/deploy_image.yml

@@ -0,0 +1,53 @@
+name: Deploy Jumble Proxy Server Container Image
+
+on:
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+' # Only build on tag with semantic versioning format
+
+jobs:
+  push_avestruz_image:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      packages: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      # Script for setting the version without the leading 'v'
+      - name: Set Versions
+        uses: actions/github-script@v7
+        id: set_version
+        with:
+          script: |
+            // Get the tag
+            const tag = context.ref.substring(10)
+            // Replace the tag with one without v
+            const no_v = tag.replace('v', '')
+            // Looks for a dash
+            const dash_index = no_v.lastIndexOf('-')
+            // If any, removes it, otherwise return the value unchanged
+            const no_dash = (dash_index > -1) ?  no_v.substring(0, dash_index) : no_v
+            // Set the tag, no-v and no-dash as output variables
+            core.setOutput('tag', tag)
+            core.setOutput('no-v', no_v)
+            core.setOutput('no-dash', no_dash)
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: ghcr.io/${{ github.actor }}/jumble-proxy-server:latest, ghcr.io/${{ github.actor }}/jumble-proxy-server:${{steps.set_version.outputs.no-dash}}
+      - name: Release
+        uses: softprops/action-gh-release@v1

.gitignore

@@ -0,0 +1,33 @@
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Code coverage profiles and other test artifacts
+*.out
+coverage.*
+*.coverprofile
+profile.cov
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+go.work
+go.work.sum
+
+# env file
+.env
+
+# Editor/IDE
+# .idea/
+# .vscode/
+bin/

Dockerfile

@@ -0,0 +1,25 @@
+FROM golang:1.24-bookworm AS build
+
+ARG TARGETOS
+ARG TARGETARCH
+
+RUN apt-get update -y \
+  && apt-get clean
+
+WORKDIR /app
+
+COPY go.* ./
+RUN go mod download
+
+COPY . .
+
+RUN CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -o jumble-proxy-server .
+
+FROM gcr.io/distroless/base-debian11 AS build-release-stage
+
+ENV PORT=8080
+ENV AllOW_ORIGIN=https://jumble.social
+
+COPY --from=build /app/jumble-proxy-server /bin/jumble-proxy-server
+
+ENTRYPOINT ["/bin/jumble-proxy-server", "server"] 

Makefile

@@ -0,0 +1,25 @@
+.PHONY: docker-build
+## docker-build: Builds the Docker image
+docker-build:
+	@docker build -t jumble-proxy-server .
+
+.PHONY: build
+## build: Builds the Go program
+build:
+	@CGO_ENABLED=0 go build -o bin/jumble-proxy-server .
+
+.PHONY: docker-run
+## docker-run: Run the container
+docker-run: docker-build
+	@docker run --rm -e ALLOW_ORIGIN=https://jumble.social -e PORT=8080 -p 8080:8080 jumble-proxy-server:latest
+
+.PHONY: test
+## test: Runs the tests
+test:
+	go test -v -race ./...
+
+.PHONY: help
+## help: Prints this help message
+help:
+	@echo "Usage:"
+	@sed -n 's/^##//p' ${MAKEFILE_LIST} | column -t -s ':' |  sed -e 's/^/ /'

README.md

@@ -1,12 +1,44 @@
 # jumble-proxy-server
 
-__This application is a proxy server used by the Jumble Nostr client as a workaround to fix CORS erros,so that the client can show the URL preview from links' Open Graph data.__
+__This application is a proxy server used by the Jumble Nostr client as a workaround to fix CORS errors, so that the client can show the URL preview from given links Open Graph data.__
 
 ## Usage
+
+### From source
+
+Compile the binary:
+
+```
+CGO_ENABLED=0 go build -o bin/jumble-proxy-server .
+```
+
+Run the binary with environment variables:
+
 ```sh
-jumble-proxy-server -a https://jumble.social -p 8080
+ALLOW_ORIGIN=https://jumble.social PORT=8080 bin/jumble-proxy-server server
+```
+
+### Using Docker
+
+Pull the image:
+
+```
+docker pull ghcr.io/danvergara/jumble-proxy-server:latest
+```
+
+Run the container;
+
 ```
+docker run docker run --rm -e ALLOW_ORIGIN=https://jumble.social -e PORT=8080 -p 8080:8080 ghcr.io/danvergara/jumble-proxy-server:latest
+
+```
+
+### How to hit the proxy server
+
+The inner URL needs to be encoded so it doesn't break the outer URL structure.
 
 ```sh
-curl -X GET http://localhost:8080/sites/https:/www.youtube.com/watch\?v\=i-OZcpNSzg0
+curl -X GET http://localhost:8080/sites/https%3A%2F%2Fyoutu.be%2FNVm_jGdwTjQ%3Fsi%3DblYLT44WrrPjL9gU
 ```
+
+The server will respond with the HTML from the website of interest.

cmd/server.go

@@ -1,16 +1,18 @@
 /*
-Copyright © 2025 NAME HERE <EMAIL ADDRESS>
+Copyright © 2025 Daniel Vergara  daniel.omar.vergara@gmail.com
 */
 package cmd
 
 import (
+	"context"
 	"fmt"
-	"io"
 	"log"
-	"net/http"
 	"os"
 
 	"github.com/spf13/cobra"
+
+	"github.com/danvergara/jumble-proxy-server/pkg/config"
+	"github.com/danvergara/jumble-proxy-server/pkg/server"
 )
 
 var (
@@ -29,72 +31,26 @@ so that the client can show the URL preview from links' Open Graph data.`,
 			port = "8000"
 		}
 
-		http.HandleFunc("GET /sites/{site}", proxyHandler)
-		if err := http.ListenAndServe(fmt.Sprintf(":%s", port), nil); err != nil {
-			fmt.Fprintf(os.Stderr, "%s\n", err)
-			os.Exit(1)
+		cfg := config.Config{
+			Port:          port,
+			AllowedOrigin: allowedOrigin,
 		}
 
 		log.Printf("server listening on port %s\n", port)
 
-		return nil
-	},
-}
-
-func proxyHandler(w http.ResponseWriter, r *http.Request) {
-	if allowedOrigin == "" {
-		allowedOrigin = "*"
-	}
-
-	w.Header().Set("Access-Control-Allow-Origin", allowedOrigin)
-	w.Header().Set("Access-Control-Allow-Methods", "GET")
-	w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
-
-	site := r.PathValue("site")
-
-	// Send request to the target site.
-	req, err := http.NewRequest(r.Method, site, r.Body)
-	if err != nil {
-		http.Error(w, "Failed to create request", http.StatusInternalServerError)
-		return
-	}
-
-	// Copy headers from original request.
-	for header, values := range r.Header {
-		for _, value := range values {
-			req.Header.Add(header, value)
-		}
-	}
-
-	// Perform the proxy request.
-	client := &http.Client{}
-	resp, err := client.Do(req)
-	if err != nil {
-		fmt.Printf("Proxy request failed %v", err)
-		http.Error(w, "Proxy request failed", http.StatusBadGateway)
-		return
-	}
-
-	defer resp.Body.Close()
-
-	// Copy the response headers.
-	for header, values := range resp.Header {
-		for _, value := range values {
-			w.Header().Add(header, value)
+		ctx := context.Background()
+		if err := server.Run(ctx, &cfg); err != nil {
+			fmt.Fprintf(os.Stderr, "%s\n", err)
+			os.Exit(1)
 		}
-	}
 
-	// Set the status code and write the response body.
-	w.WriteHeader(resp.StatusCode)
-	body, _ := io.ReadAll(resp.Body)
-	w.Write(body)
+		return nil
+	},
 }
 
 func init() {
 	rootCmd.AddCommand(serverCmd)
 
-	serverCmd.Flags().
-		StringVarP(&allowedOrigin, "allowed-origin", "a", "", "Restrict access to a specific allowed domain")
-	serverCmd.Flags().
-		StringVarP(&port, "port", "p", "", "Server Port")
+	port = os.Getenv("PORT")
+	allowedOrigin = os.Getenv("ALLOW_ORIGIN")
 }

pkg/config/config.go

@@ -0,0 +1,7 @@
+package config
+
+type Config struct {
+	Host          string
+	Port          string
+	AllowedOrigin string
+}

pkg/server/handlers.go

@@ -0,0 +1,65 @@
+package server
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+
+	"github.com/danvergara/jumble-proxy-server/pkg/config"
+)
+
+// proxyHandler adds headers to overcome the CORS errors for the Jumble Nostr client.
+func proxyHandler(config *config.Config) func(w http.ResponseWriter, r *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
+		allowedOrigin := config.AllowedOrigin
+
+		if allowedOrigin == "" {
+			allowedOrigin = "*"
+		}
+
+		// add the paraters to fix CORS issues.
+		w.Header().Set("Access-Control-Allow-Origin", allowedOrigin)
+		w.Header().Set("Access-Control-Allow-Methods", "GET")
+		w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
+
+		// get the site of interest from the path parameters.
+		site := r.PathValue("site")
+
+		// Send request to the target site.
+		req, err := http.NewRequest(r.Method, site, r.Body)
+		if err != nil {
+			http.Error(w, "Failed to create request", http.StatusInternalServerError)
+			return
+		}
+
+		// Copy headers from original request.
+		for header, values := range r.Header {
+			for _, value := range values {
+				req.Header.Add(header, value)
+			}
+		}
+
+		// Perform the proxy request.
+		client := &http.Client{}
+		resp, err := client.Do(req)
+		if err != nil {
+			fmt.Printf("proxy request failed %v", err)
+			http.Error(w, "proxy request failed", http.StatusBadGateway)
+			return
+		}
+
+		defer resp.Body.Close()
+
+		// Copy the response headers.
+		for header, values := range resp.Header {
+			for _, value := range values {
+				w.Header().Add(header, value)
+			}
+		}
+
+		// Set the status code and write the response body.
+		w.WriteHeader(resp.StatusCode)
+		body, _ := io.ReadAll(resp.Body)
+		w.Write(body)
+	}
+}

pkg/server/middlewares.go

@@ -0,0 +1,14 @@
+package server
+
+import (
+	"log"
+	"net/http"
+)
+
+func loggingMiddlware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		site := r.PathValue("site")
+		log.Printf("fetching site: %s\n", site)
+		next.ServeHTTP(w, r)
+	})
+}