golang > python

better now

Author: tester2024

README.md

@@ -0,0 +1,102 @@
+# SteamDownloaderAPI
+
+[![Go Report Card](https://goreportcard.com/badge/github.com/SyNdicateFoundation/SteamDownloaderAPI)](https://goreportcard.com/report/github.com/SyNdicateFoundation/SteamDownloaderAPI)
+[![Go Build](https://github.com/SyNdicateFoundation/SteamDownloaderAPI/actions/workflows/go.yml/badge.svg)](https://github.com/SyNdicateFoundation/SteamDownloaderAPI/actions/workflows/go.yml)
+
+A powerful Go-based reverse proxy for the Steam Workshop that dynamically injects download buttons into workshop and collection pages, allowing you to download items directly using a backend `steamcmd` instance.
+
+***
+
+## Overview
+
+This project acts as a middleman between you and the Steam Community website. When you browse a Steam Workshop page through this proxy, it intelligently modifies the page on-the-fly to add "Download" buttons next to the standard "Subscribe" buttons. Clicking these new buttons triggers a backend process that uses `steamcmd` to download the workshop files to your server.
+
+This is perfect for server administrators, content curators, or anyone who needs to obtain workshop files without subscribing to them through the Steam client.
+
+***
+
+## Features
+
+-   **Reverse Proxy for Steam Workshop**: Forwards requests to `steamcommunity.com` seamlessly.
+-   **Dynamic Content Injection**: Injects "Download" and "Download Collection" buttons directly into the HTML using `goquery`.
+-   **URL Rewriting**: All asset URLs (CSS, JS, images) are rewritten to be served through the proxy, ensuring pages render correctly.
+-   **`steamcmd` Integration**: Leverages a `steamcmd` wrapper to handle the actual download logic.
+-   **Configurable Startup**: Use command-line flags to easily configure server settings.
+
+***
+
+## How It Works
+
+1.  The user navigates to a proxied Steam Workshop URL (e.g., `http://localhost:8080/workshop/filedetails/?id=123456789`).
+2.  The `SteamProxyHandler` receives the request and forwards it to the official Steam servers.
+3.  Before sending the response back to the user, the `ModifyResponse` function intercepts it.
+4.  The HTML body is parsed. The proxy finds all "Subscribe" buttons and injects new `<a>` tags next to them, pointing to the downloader API endpoints.
+5.  All other URLs within the page (`href`, `src`, `srcset`) are rewritten to be relative, ensuring all subsequent requests for assets also go through the proxy.
+6.  The modified, uncompressed HTML is sent to the user's browser.
+7.  When the user clicks a "Download" button, a request is sent to an API endpoint like `/api/workshop/:app_id/:workshop_id`.
+8.  The API handler calls the `steamcmd` wrapper, which executes the necessary commands (`workshop_download_item`) to download the files to the server.
+
+***
+
+## API Endpoints
+
+-   `GET /api/workshop/:app_id/:workshop_id`
+    -   Triggers a download for a single workshop item.
+    -   **`app_id`**: The ID of the game (e.g., `4000` for Garry's Mod).
+    -   **`workshop_id`**: The ID of the workshop file.
+
+-   `GET /api/collection/:app_id/:collection_id`
+    -   Triggers a download for all items within a collection.
+    -   **`app_id`**: The ID of the game.
+    -   **`collection_id`**: The ID of the workshop collection.
+
+***
+
+## Setup and Installation
+
+### Prerequisites
+
+-   [Go](https://golang.org/doc/install) (version 1.18 or newer)
+-   A working installation of [`steamcmd`](https://developer.valvesoftware.com/wiki/SteamCMD) on the server where this API will run (or let the app install it for you).
+
+### Steps
+
+1.  **Clone the repository:**
+    ```sh
+    git clone https://github.com/SyNdicateFoundation/SteamDownloaderAPI.git
+    cd SteamDownloaderAPI
+    ```
+
+2.  **Install dependencies:**
+    ```sh
+    go mod tidy
+    ```
+
+3.  **Build the application:**
+    ```sh
+    go build -o steamdownloaderapi ./cmd/main.go
+    ```
+
+***
+
+## Configuration & Usage
+
+The application is configured at startup using command-line flags.
+
+### Available Flags
+
+-   `-listenhost`: The hostname or IP address for the server to listen on. (Default: `0.0.0.0`)
+-   `-listenport`: The port for the server to listen on. (Default: `8080`)
+-   `-steamcmdpath`: The directory path for `steamcmd`. (Default: `steamcmd`)
+-   `-installsteamcmd`: If `true`, the application will install or update `steamcmd` on startup. (Default: `true`)
+-   `-debug`: Enables debug mode for more verbose logging. (Default: `false`)
+-   `-steamuser`: Your Steam username. Required for downloading certain content. (Default: `""`, will login as anonymous)
+-   `-steampassword`: Your Steam password. (Default: `""`)
+
+### Running the Server
+
+Once built, you can run the application from your terminal.
+
+**Basic startup (installs steamcmd to a 'steamcmd' folder and runs on port 8080):**
+```sh
+./steamdownloaderapi -steamuser your_username -steampassword your_password

cmd/server/main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"flag"
 	"log"
+	"net"
 	"net/http"
 	"os"
 
@@ -11,19 +12,32 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-func main() {
-	steamCmdPath := flag.String("steamcmdpath", "steamcmd", "Path to the steamcmd directory")
-	port := flag.String("port", "8080", "Port for the server to listen on")
-	install := flag.Bool("install", true, "Install or update steamcmd on startup")
+var (
+	steamCmdPath, listenHost, listenPort, steamUser, steamPassword string
+	installSteamCmd, debugMode                                     bool
+)
+
+func init() {
+	flag.StringVar(&steamCmdPath, "steamcmdpath", "steamcmd", "Path to the steamcmd directory")
+	flag.BoolVar(&installSteamCmd, "installsteamcmd", true, "Install steamcmd")
+	flag.BoolVar(&debugMode, "debug", false, "Install steamcmd")
+	flag.StringVar(&listenHost, "listenhost", "0.0.0.0", "Hostname for the server to listen on")
+	flag.StringVar(&listenPort, "listenport", "8080", "Port for the server to listen on")
+	flag.StringVar(&steamUser, "steamuser", "", "Steam username")
+	flag.StringVar(&steamPassword, "steampassword", "", "Steam password")
+
 	flag.Parse()
+}
+
+func main() {
 
-	s, err := steamcmd.New(*steamCmdPath)
+	s, err := steamcmd.New(steamCmdPath, steamUser, steamPassword)
 	if err != nil {
 		log.Fatalf("❌ SteamCMD initialization error: %v", err)
 	}
 
-	if *install {
-		if err := os.MkdirAll(*steamCmdPath, 0755); err != nil {
+	if installSteamCmd {
+		if err := os.MkdirAll(steamCmdPath, 0755); err != nil {
 			log.Fatalf("❌ Failed to create steamcmd directory: %v", err)
 		}
 
@@ -34,6 +48,12 @@ func main() {
 
 	router := gin.Default()
 
+	gin.SetMode(gin.ReleaseMode)
+
+	if debugMode {
+		gin.SetMode(gin.DebugMode)
+	}
+
 	h := handler.New(s)
 	defer h.Cleanup()
 
@@ -56,8 +76,11 @@ func main() {
 		router.GET(route, h.UnsupportedPageHandler)
 	}
 
-	log.Printf("🚀 Server starting on http://0.0.0.0:%s", *port)
-	if err := router.Run(":" + *port); err != nil {
+	listenAddr := net.JoinHostPort(listenHost, listenPort)
+
+	log.Printf("🚀 Server starting on http://%s", listenAddr)
+
+	if err := router.Run(listenAddr); err != nil {
 		log.Fatalf("❌ Failed to start server: %v", err)
 	}
 }

github/workflows/go-build.yml

@@ -0,0 +1,31 @@
+name: Create GitHub Release
+
+on:
+  push:
+    tags:
+      - 'v*.*.*'
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.21'
+
+      - name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@v5
+        with:
+          version: latest
+          args: release --clean
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

internal/steamcmd/steamcmd.go

@@ -15,9 +15,11 @@ import (
 type SteamCMD struct {
 	InstallPath string
 	ExePath     string
+	username    string
+	password    string
 }
 
-func New(installPath string) (*SteamCMD, error) {
+func New(installPath string, username string, password string) (*SteamCMD, error) {
 	exeName := "steamcmd"
 	if runtime.GOOS == "windows" {
 		exeName += ".exe"
@@ -33,6 +35,8 @@ func New(installPath string) (*SteamCMD, error) {
 	return &SteamCMD{
 		InstallPath: installPath,
 		ExePath:     absExePath,
+		username:    username,
+		password:    password,
 	}, nil
 }
 
@@ -99,10 +103,17 @@ func (s *SteamCMD) finalizeInstallation() error {
 }
 
 func (s *SteamCMD) DownloadWorkshopItem(appID, workshopID int, validate bool) error {
-	args := []string{
-		"+login", "anonymous",
-		"+workshop_download_item", fmt.Sprint(appID), fmt.Sprint(workshopID),
+	loginInfo := []string{"+login", "anonymous"}
+
+	if s.username != "" {
+		loginInfo = append(loginInfo, "+login", s.username, s.password)
 	}
+
+	args := append(
+		loginInfo,
+		[]string{"+workshop_download_item", fmt.Sprint(appID), fmt.Sprint(workshopID)}...,
+	)
+
 	if validate {
 		args = append(args, "validate")
 	}
@@ -114,13 +125,12 @@ func (s *SteamCMD) DownloadWorkshopItem(appID, workshopID int, validate bool) er
 	cmd.Stderr = os.Stderr
 
 	if err := cmd.Run(); err != nil {
-
-		log.Printf("   Retrying download for WorkshopID %d...", workshopID)
 		time.Sleep(2 * time.Second)
 		if errRetry := cmd.Run(); errRetry != nil {
 			return fmt.Errorf("steamcmd execution failed after retry: %w", errRetry)
 		}
 	}
+
 	return nil
 }