Deploy hf-save: Go API backend and multi-platform CLI installer

Dockerfile

@@ -0,0 +1,42 @@
+# Build Stage
+FROM golang:1.21-alpine AS builder
+
+WORKDIR /app
+
+# Copy the server and cli source code
+COPY main.go go.mod ./
+COPY cli/ cli/
+
+# Create directory to store precompiled binaries
+RUN mkdir -p bin
+
+# Cross-compile CLI for various target OS and architectures
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -o bin/linux-amd64 cli/main.go
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -ldflags="-s -w" -o bin/linux-arm64 cli/main.go
+RUN CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -ldflags="-s -w" -o bin/windows-amd64 cli/main.go
+RUN CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build -ldflags="-s -w" -o bin/darwin-amd64 cli/main.go
+RUN CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -ldflags="-s -w" -o bin/darwin-arm64 cli/main.go
+
+# Build the main server binary statically linked
+RUN CGO_ENABLED=0 go build -ldflags="-s -w" -o server main.go
+
+# Production Stage
+FROM scratch
+
+WORKDIR /app
+
+# Copy the server binary and precompiled CLI binaries
+COPY --from=builder /app/server /app/server
+COPY --from=builder /app/bin /app/bin
+
+# Environment variables (Can be overridden in HF Spaces configuration)
+ENV DATA_DIR=/data
+ENV BIN_DIR=/app/bin
+ENV PORT=7860
+
+# Expose default HF Spaces port
+EXPOSE 7860
+
+# Command to run backend
+CMD ["/app/server"]
+

README.md

@@ -1,10 +1,91 @@
 ---
-title: Store
-emoji: 😻
+title: hf-save
+emoji: 💾
 colorFrom: blue
 colorTo: indigo
 sdk: docker
+app_port: 7860
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# hf-save
+
+An ultra-fast, zero-overhead developer tool to save work artifacts from ephemeral GPU instances (RunPod, Vast.ai, Lambda Labs) and restore them later. 
+
+Uses a **Hugging Face Docker Space** with a **Dataset Storage Mount** at `/data` as the backend and a **Single-binary Go CLI** on the client side.
+
+
+---
+
+## Deploying the Backend Space
+
+1. Create a new Space on [Hugging Face](https://huggingface.co/spaces).
+2. Set the SDK to **Docker** (Blank template).
+3. **Set up Persistent Storage / Dataset Mount**:
+   * Mount a dataset repository at `/data` inside your Space configuration settings.
+4. **Set environment variable**:
+   * In your Space's settings, add a new Secret variable: `HF_SAVE_API_KEY` (e.g. `my-super-secret-key-123`). This will authenticate client-side uploads.
+5. Clone your space repository locally, copy the repository files (`main.go`, `cli/`, `Dockerfile`, `go.mod`), commit and push to the Space repo. Hugging Face will automatically compile the server and build the CLI binaries for Linux, macOS, and Windows.
+
+---
+
+## Client Installation
+
+To install the client binary on any GPU instance or development machine, run the appropriate command. Replace `your-space-name.hf.space` with your actual Hugging Face Space hostname.
+
+### Linux:
+```bash
+curl -fsSL "https://your-space-name.hf.space/init?platform=linux&token=YOUR_API_KEY" | bash
+```
+
+### Windows (PowerShell):
+```powershell
+irm "https://your-space-name.hf.space/init?platform=windows&token=YOUR_API_KEY" | iex
+```
+
+### macOS:
+```bash
+curl -fsSL "https://your-space-name.hf.space/init?platform=mac&token=YOUR_API_KEY" | bash
+```
+
+*Note: If you omit the `&token=YOUR_API_KEY` parameter from the URL, the installer will interactively prompt you to enter the API Key during setup.*
+
+---
+
+## CLI Usage Guide
+
+Once installed, use the CLI commands to backup and restore files.
+
+### 1. Saving Directories
+To backup folders at the end of a session:
+```bash
+# Save a single directory
+hf-save outputs
+
+# Save multiple directories
+hf-save outputs logs checkpoints
+```
+This scans files, filters out binary/bloat directories (like `.git`, `__pycache__`, `venv`), and streams them directly to `/data/{YYYY-MM-DD}/{HH-MM-SS}_{name}` on your backend.
+
+### 2. Listing Backups
+List all backup dates:
+```bash
+hf-list
+```
+
+List individual snapshots for a specific date:
+```bash
+hf-list 2026-06-15
+```
+
+### 3. Restoring Backups
+To restore the **latest** backup of a specific folder name automatically:
+```bash
+hf-mount outputs
+```
+
+To restore a **specific** timestamped backup run:
+```bash
+hf-mount 2026-06-15 16-35-20_outputs
+```
+This downloads the files and reconstructs the folders inside your current working directory.

cli/main.go

@@ -0,0 +1,550 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+
+type Config struct {
+	ServerURL string `json:"server_url"`
+	APIKey    string `json:"api_key"`
+}
+
+func main() {
+	if len(os.Args) < 2 {
+		printUsageAndExit()
+	}
+
+	command := os.Args[1]
+
+	// Help check
+	if command == "-h" || command == "--help" || command == "help" {
+		printUsageAndExit()
+	}
+
+	switch command {
+	case "save":
+		// User can run either: hf-save <dirs>... OR hf-save save <dirs>...
+		// We'll support both, but the primary expectation is: hf-save outputs logs
+		if len(os.Args) < 3 {
+			fmt.Println("Error: No directories specified to save.")
+			os.Exit(1)
+		}
+		runSave(os.Args[2:])
+	case "list":
+		// user runs hf-list or hf-save list
+		date := ""
+		if len(os.Args) > 2 {
+			date = os.Args[2]
+		}
+		runList(date)
+	case "mount":
+		// hf-mount outputs OR hf-mount 2026-06-15 16-35-20_outputs
+		if len(os.Args) < 3 {
+			fmt.Println("Error: Please specify what to restore.")
+			os.Exit(1)
+		}
+		runMount(os.Args[2:])
+	default:
+		// If command is not recognized, treat all arguments as directories to save
+		// This enables direct usage like: hf-save outputs logs
+		runSave(os.Args[1:])
+	}
+}
+
+func printUsageAndExit() {
+	fmt.Println(`hf-save: Extreme fast backup/restore tool for ephemeral GPU instances
+
+Usage:
+  hf-save <dir1> [dir2]...   Save directories to the backup server
+  hf-list                    List available backup dates
+  hf-list <date>             List all backups on a specific date (e.g. hf-list 2026-06-15)
+  hf-mount <dir_name>        Restore latest backup containing directory name
+  hf-mount <date> <run>      Restore specific backup run (e.g. hf-mount 2026-06-15 16-35-20_outputs)
+
+Aliases / Subcommands:
+  hf-save save <dir>...
+  hf-save list [date]
+  hf-save mount <args>...
+`)
+	os.Exit(0)
+}
+
+func loadConfig() Config {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		fmt.Printf("Error determining user home directory: %v\n", err)
+		os.Exit(1)
+	}
+
+	configPath := filepath.Join(home, ".config", "hf-save", "config.json")
+	file, err := os.Open(configPath)
+	if err != nil {
+		fmt.Printf("Error: Configuration file not found at %s. Please run the init script first.\n", configPath)
+		os.Exit(1)
+	}
+	defer file.Close()
+
+	var cfg Config
+	if err := json.NewDecoder(file).Decode(&cfg); err != nil {
+		fmt.Printf("Error parsing configuration: %v\n", err)
+		os.Exit(1)
+	}
+
+	cfg.ServerURL = strings.TrimSuffix(cfg.ServerURL, "/")
+	return cfg
+}
+
+type uploadFile struct {
+	relPath string
+	absPath string
+}
+
+func ensureServerAwake(serverURL string) {
+	client := &http.Client{Timeout: 5 * time.Second}
+	fmt.Print("Checking connection to backup server... ")
+
+	for i := 0; i < 30; i++ {
+		resp, err := client.Get(serverURL + "/health")
+		if err == nil {
+			if resp.StatusCode == http.StatusOK {
+				resp.Body.Close()
+				fmt.Println("Connected.")
+				return
+			}
+			resp.Body.Close()
+		}
+
+		if i == 0 {
+			fmt.Println("\nServer is asleep or starting up. Waking it up (this may take 1-2 minutes)...")
+		}
+
+		fmt.Printf("Waiting for server to wake up... (Attempt %d/30)\r", i+1)
+		time.Sleep(5 * time.Second)
+	}
+
+	fmt.Println("\nWarning: Could not verify server is awake. Attempting operation anyway...")
+}
+
+type progressReader struct {
+	r       io.Reader
+	total   int64
+	current int64
+}
+
+func (pr *progressReader) Read(p []byte) (n int, err error) {
+	n, err = pr.r.Read(p)
+	if n > 0 {
+		pr.current += int64(n)
+		percent := float64(pr.current) / float64(pr.total) * 100
+		mbCurrent := float64(pr.current) / (1024 * 1024)
+		mbTotal := float64(pr.total) / (1024 * 1024)
+		fmt.Printf("Uploading: %.1f%% (%.1f/%.1f MB)\r", percent, mbCurrent, mbTotal)
+	}
+	return
+}
+
+type writeCounter struct {
+	total   int64
+	current int64
+	name    string
+}
+
+func (wc *writeCounter) Write(p []byte) (int, error) {
+	n := len(p)
+	wc.current += int64(n)
+	percent := float64(wc.current) / float64(wc.total) * 100
+	mbCurrent := float64(wc.current) / (1024 * 1024)
+	mbTotal := float64(wc.total) / (1024 * 1024)
+	fmt.Printf("Downloading %s: %.1f%% (%.1f/%.1f MB)\r", wc.name, percent, mbCurrent, mbTotal)
+	return n, nil
+}
+
+var quoteEscaper = strings.NewReplacer("\\", "\\\\", "\"", "\\\"")
+
+func escapeQuotes(s string) string {
+	return quoteEscaper.Replace(s)
+}
+
+func calculateUploadSize(prefix string, files []uploadFile, boundary string) (int64, error) {
+	var totalSize int64
+
+	// 1. Prefix field size
+	var prefixBuf bytes.Buffer
+	w := multipart.NewWriter(&prefixBuf)
+	w.SetBoundary(boundary)
+	_ = w.WriteField("prefix", prefix)
+	totalSize += int64(prefixBuf.Len())
+
+	// 2. Files size
+	for _, file := range files {
+		var fileHeaderBuf bytes.Buffer
+		fw := multipart.NewWriter(&fileHeaderBuf)
+		fw.SetBoundary(boundary)
+		_, err := fw.CreateFormFile("files", file.relPath)
+		if err != nil {
+			return 0, err
+		}
+		totalSize += int64(fileHeaderBuf.Len())
+
+		info, err := os.Stat(file.absPath)
+		if err != nil {
+			return 0, err
+		}
+		totalSize += info.Size()
+		totalSize += 2 // trailing \r\n after file part data
+	}
+
+	// 3. Closing boundary size (\r\n--boundary--\r\n)
+	totalSize += int64(len("\r\n--" + boundary + "--\r\n"))
+
+	return totalSize, nil
+}
+
+// bytes helper import for size calculation
+type bytesBufferWriter struct {
+	bytes.Buffer
+}
+
+func runSave(targets []string) {
+	cfg := loadConfig()
+	ensureServerAwake(cfg.ServerURL)
+
+	for _, target := range targets {
+		saveSingleTarget(cfg, target)
+	}
+}
+
+func saveSingleTarget(cfg Config, target string) {
+	cleanDir := filepath.Clean(target)
+	info, err := os.Stat(cleanDir)
+	if err != nil {
+		fmt.Printf("Error: Target '%s' not found, skipping.\n", target)
+		return
+	}
+
+	var filesToUpload []uploadFile
+
+	if !info.IsDir() {
+		filesToUpload = append(filesToUpload, uploadFile{
+			relPath: filepath.Base(cleanDir),
+			absPath: cleanDir,
+		})
+	} else {
+		err = filepath.Walk(cleanDir, func(path string, fileInfo os.FileInfo, walkErr error) error {
+			if walkErr != nil {
+				return walkErr
+			}
+			if fileInfo.IsDir() {
+				return nil
+			}
+
+			parts := strings.Split(path, string(filepath.Separator))
+			for _, part := range parts {
+				if part == ".git" || part == "node_modules" || part == "__pycache__" || part == ".venv" || part == "venv" {
+					return nil
+				}
+			}
+
+			rel, err := filepath.Rel(filepath.Dir(cleanDir), path)
+			if err == nil {
+				filesToUpload = append(filesToUpload, uploadFile{
+					relPath: filepath.ToSlash(rel),
+					absPath: path,
+				})
+			}
+			return nil
+		})
+		if err != nil {
+			fmt.Printf("Error scanning target %s: %v\n", target, err)
+			return
+		}
+	}
+
+	if len(filesToUpload) == 0 {
+		fmt.Printf("No files found to save in target %s.\n", target)
+		return
+	}
+
+	dateStr := time.Now().Format("2006-01-02")
+	timeStr := time.Now().Format("15-04-05")
+	folderSuffix := filepath.Base(cleanDir)
+	prefix := fmt.Sprintf("%s/%s_%s", dateStr, timeStr, folderSuffix)
+
+	fmt.Printf("\n--- Saving target: %s (%d files) ---\n", target, len(filesToUpload))
+	fmt.Printf("Uploading snapshot: %s\n", prefix)
+
+	// Create a dummy multipart writer to generate a consistent boundary string
+	dummyWriter := multipart.NewWriter(nil)
+	boundary := dummyWriter.Boundary()
+
+	totalSize, err := calculateUploadSize(prefix, filesToUpload, boundary)
+	if err != nil {
+		fmt.Printf("Failed to calculate upload size: %v\n", err)
+		return
+	}
+
+	pipeReader, pipeWriter := io.Pipe()
+	writer := multipart.NewWriter(pipeWriter)
+	writer.SetBoundary(boundary)
+
+	go func() {
+		defer pipeWriter.Close()
+		defer writer.Close()
+
+		err := writer.WriteField("prefix", prefix)
+		if err != nil {
+			return
+		}
+
+		for _, file := range filesToUpload {
+			fileWriter, err := writer.CreateFormFile("files", file.relPath)
+			if err != nil {
+				return
+			}
+
+			f, err := os.Open(file.absPath)
+			if err != nil {
+				return
+			}
+
+			_, err = io.Copy(fileWriter, f)
+			f.Close()
+			if err != nil {
+				return
+			}
+		}
+	}()
+
+	reqURL := fmt.Sprintf("%s/upload", cfg.ServerURL)
+	pr := &progressReader{
+		r:     pipeReader,
+		total: totalSize,
+	}
+
+	req, err := http.NewRequest(http.MethodPost, reqURL, pr)
+	if err != nil {
+		fmt.Printf("Error creating upload request: %v\n", err)
+		return
+	}
+
+	req.Header.Set("Content-Type", writer.FormDataContentType())
+	req.ContentLength = totalSize
+	if cfg.APIKey != "" {
+		req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", cfg.APIKey))
+	}
+
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		fmt.Printf("\nUpload failed: %v\n", err)
+		return
+	}
+	defer resp.Body.Close()
+	fmt.Println() // print newline after progress percentage
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		fmt.Printf("Upload failed with status %s: %s\n", resp.Status, string(body))
+		return
+	}
+
+	var result map[string]interface{}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err == nil {
+		fmt.Printf("Successfully saved %s! (%v files)\n", target, result["file_count"])
+	} else {
+		fmt.Printf("Successfully saved %s!\n", target)
+	}
+}
+
+func runList(date string) {
+	cfg := loadConfig()
+	ensureServerAwake(cfg.ServerURL)
+
+	reqURL := fmt.Sprintf("%s/list", cfg.ServerURL)
+	if date != "" {
+		reqURL += "?date=" + date
+	}
+
+	resp, err := http.Get(reqURL)
+	if err != nil {
+		fmt.Printf("Request failed: %v\n", err)
+		os.Exit(1)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		fmt.Printf("Request failed: %s\n", resp.Status)
+		os.Exit(1)
+	}
+
+	var results []string
+	if err := json.NewDecoder(resp.Body).Decode(&results); err != nil {
+		fmt.Printf("Failed to decode response: %v\n", err)
+		os.Exit(1)
+	}
+
+	if len(results) == 0 {
+		fmt.Println("No backups found.")
+		return
+	}
+
+	for _, item := range results {
+		fmt.Println(item)
+	}
+}
+
+func runMount(args []string) {
+	cfg := loadConfig()
+	ensureServerAwake(cfg.ServerURL)
+
+	var snapshot string
+
+	if len(args) == 1 {
+		folderName := args[0]
+		dates, err := fetchList(cfg.ServerURL, "")
+		if err != nil {
+			fmt.Printf("Error: Failed to fetch date indexes: %v\n", err)
+			os.Exit(1)
+		}
+
+		found := false
+		for i := len(dates) - 1; i >= 0; i-- {
+			runs, err := fetchList(cfg.ServerURL, dates[i])
+			if err != nil {
+				continue
+			}
+
+			for j := len(runs) - 1; j >= 0; j-- {
+				if strings.HasSuffix(runs[j], "_"+folderName) {
+					snapshot = dates[i] + "/" + runs[j]
+					found = true
+					break
+				}
+			}
+			if found {
+				break
+			}
+		}
+
+		if !found {
+			fmt.Printf("Error: No backups found matching folder name: %s\n", folderName)
+			os.Exit(1)
+		}
+
+	} else if len(args) == 2 {
+		snapshot = args[0] + "/" + args[1]
+	} else {
+		fmt.Println("Error: Invalid arguments for mount command.")
+		os.Exit(1)
+	}
+
+	fmt.Printf("Mounting snapshot: %s\n", snapshot)
+
+	manifestURL := fmt.Sprintf("%s/download?snapshot=%s", cfg.ServerURL, snapshot)
+	resp, err := http.Get(manifestURL)
+	if err != nil {
+		fmt.Printf("Failed to download snapshot manifest: %v\n", err)
+		os.Exit(1)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		fmt.Printf("Failed to fetch manifest: %s - %s\n", resp.Status, string(body))
+		os.Exit(1)
+	}
+
+	var files []string
+	if err := json.NewDecoder(resp.Body).Decode(&files); err != nil {
+		fmt.Printf("Failed to decode snapshot list: %v\n", err)
+		os.Exit(1)
+	}
+
+	if len(files) == 0 {
+		fmt.Println("Snapshot is empty.")
+		return
+	}
+
+	fmt.Printf("Restoring %d files...\n", len(files))
+
+	for _, file := range files {
+		targetLocalPath := filepath.FromSlash(file)
+		localDir := filepath.Dir(targetLocalPath)
+		if localDir != "." {
+			if err := os.MkdirAll(localDir, 0755); err != nil {
+				fmt.Printf("Failed to create folder %s: %v\n", localDir, err)
+				os.Exit(1)
+			}
+		}
+
+		fileURL := fmt.Sprintf("%s/download?file=%s/%s", cfg.ServerURL, snapshot, file)
+		err = downloadFile(fileURL, targetLocalPath, filepath.Base(targetLocalPath))
+		if err != nil {
+			fmt.Printf("Error downloading file %s: %v\n", file, err)
+			os.Exit(1)
+		}
+	}
+
+	fmt.Println("Restore completed successfully!")
+}
+
+func fetchList(serverURL, date string) ([]string, error) {
+	reqURL := fmt.Sprintf("%s/list", serverURL)
+	if date != "" {
+		reqURL += "?date=" + date
+	}
+
+	resp, err := http.Get(reqURL)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("unexpected status %s", resp.Status)
+	}
+
+	var res []string
+	err = json.NewDecoder(resp.Body).Decode(&res)
+	return res, err
+}
+
+func downloadFile(url, dest string, fileName string) error {
+	resp, err := http.Get(url)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("server returned %s - %s", resp.Status, string(body))
+	}
+
+	out, err := os.Create(dest)
+	if err != nil {
+		return err
+	}
+	defer out.Close()
+
+	if resp.ContentLength > 5*1024*1024 {
+		counter := &writeCounter{total: resp.ContentLength, name: fileName}
+		_, err = io.Copy(out, io.TeeReader(resp.Body, counter))
+		fmt.Println()
+	} else {
+		fmt.Printf("Downloading %s...\n", fileName)
+		_, err = io.Copy(out, resp.Body)
+	}
+	return err
+}
+

go.mod

@@ -0,0 +1,3 @@
+module hf-save
+
+go 1.26.4

main.go

@@ -0,0 +1,464 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+var (
+	dataDir   = "/data"
+	binDir    = "/app/bin"
+	apiKey    = ""
+	port      = "7860" // Hugging Face Spaces default port
+)
+
+func init() {
+	if val, ok := os.LookupEnv("DATA_DIR"); ok {
+		dataDir = val
+	}
+	if val, ok := os.LookupEnv("BIN_DIR"); ok {
+		binDir = val
+	}
+	if val, ok := os.LookupEnv("HF_SAVE_API_KEY"); ok {
+		apiKey = val
+	} else {
+		log.Println("WARNING: HF_SAVE_API_KEY environment variable is not set. Write access will not be authenticated.")
+	}
+	if val, ok := os.LookupEnv("PORT"); ok {
+		port = val
+	}
+
+	// Ensure data directory exists
+	if err := os.MkdirAll(dataDir, 0755); err != nil {
+		log.Fatalf("Failed to create data directory %s: %v", dataDir, err)
+	}
+}
+
+func main() {
+	// API key middleware for write operations
+	authRequired := func(next http.HandlerFunc) http.HandlerFunc {
+		return func(w http.ResponseWriter, r *http.Request) {
+			if apiKey == "" {
+				next(w, r)
+				return
+			}
+			authHeader := r.Header.Get("Authorization")
+			if !strings.HasPrefix(authHeader, "Bearer ") {
+				http.Error(w, "Unauthorized: Missing or invalid Authorization header", http.StatusUnauthorized)
+				return
+			}
+			token := strings.TrimPrefix(authHeader, "Bearer ")
+			if token != apiKey {
+				http.Error(w, "Unauthorized: Invalid API key", http.StatusUnauthorized)
+				return
+			}
+			next(w, r)
+		}
+	}
+
+	http.HandleFunc("/init", handleInit)
+	http.HandleFunc("/bin/", handleServeBinaries)
+	http.HandleFunc("/upload", authRequired(handleUpload))
+	http.HandleFunc("/list", handleList)
+	http.HandleFunc("/download", handleDownload)
+	http.HandleFunc("/health", handleHealth)
+
+	log.Printf("Server starting on port %s...", port)
+	log.Printf("Data directory: %s", dataDir)
+	log.Printf("Binaries directory: %s", binDir)
+	if err := http.ListenAndServe(":"+port, nil); err != nil {
+		log.Fatalf("Server failed: %v", err)
+	}
+}
+
+func handleHealth(w http.ResponseWriter, r *http.Request) {
+	w.WriteHeader(http.StatusOK)
+	w.Write([]byte("OK"))
+}
+
+// Serves the install script for various platforms
+func handleInit(w http.ResponseWriter, r *http.Request) {
+	platform := r.URL.Query().Get("platform")
+	host := r.Host
+	scheme := "https"
+	if r.TLS == nil && !strings.Contains(host, "hf.space") {
+		scheme = "http"
+	}
+	serverURL := fmt.Sprintf("%s://%s", scheme, host)
+
+	// If token isn't passed, CLI will prompt the user to input the pre-shared key during setup
+	token := r.URL.Query().Get("token")
+
+	w.Header().Set("Content-Type", "text/plain")
+
+	switch strings.ToLower(platform) {
+	case "windows":
+		// PowerShell script
+		script := fmt.Sprintf(`$ServerUrl = "%s"
+$Token = "%s"
+$BinDir = "$HOME\.local\bin"
+if (!(Test-Path $BinDir)) { New-Item -ItemType Directory -Force -Path $BinDir }
+$ExePath = "$BinDir\hf-save.exe"
+Write-Host "Downloading hf-save CLI..." -ForegroundColor Cyan
+Invoke-WebRequest -Uri "$ServerUrl/bin/windows-amd64" -OutFile $ExePath
+if (!(($env:Path -split ';') -contains $BinDir)) {
+    [System.Environment]::SetEnvironmentVariable("Path", $env:Path + ";$BinDir", "User")
+    $env:Path += ";$BinDir"
+    Write-Host "Added $BinDir to PATH. You may need to restart your terminal." -ForegroundColor Yellow
+}
+$ConfigDir = "$HOME\.config\hf-save"
+if (!(Test-Path $ConfigDir)) { New-Item -ItemType Directory -Force -Path $ConfigDir }
+if ($Token -eq "") {
+    $Token = Read-Host "Enter your HF_SAVE_API_KEY (Pre-shared API Key)"
+}
+$Config = @{
+    server_url = $ServerUrl
+    api_key = $Token
+} | ConvertTo-Json
+$Config | Out-File -FilePath "$ConfigDir\config.json" -Encoding utf8
+Write-Host "Installation successful! Try running: hf-save --help" -ForegroundColor Green
+`, serverURL, token)
+		w.Write([]byte(script))
+
+	case "mac", "darwin":
+		// Bash/Zsh script for macOS
+		script := fmt.Sprintf(`#!/bin/bash
+set -e
+SERVER_URL="%s"
+TOKEN="%s"
+BIN_DIR="$HOME/.local/bin"
+mkdir -p "$BIN_DIR"
+# Determine CPU architecture
+ARCH="amd64"
+if [[ "$(uname -m)" == "arm64" ]]; then
+    ARCH="arm64"
+fi
+echo "Downloading hf-save CLI for macOS ($ARCH)..."
+curl -fsSL "$SERVER_URL/bin/darwin-$ARCH" -o "$BIN_DIR/hf-save"
+chmod +x "$BIN_DIR/hf-save"
+
+# Add to path helper
+if [[ ":$PATH:" != *":$BIN_DIR:"* ]]; then
+    echo "Adding $BIN_DIR to PATH in shell profile..."
+    if [[ "$SHELL" == */zsh ]]; then
+        echo 'export PATH="$HOME/.local/bin:$PATH"' >> "$HOME/.zshrc"
+    else
+        echo 'export PATH="$HOME/.local/bin:$PATH"' >> "$HOME/.bashrc"
+    fi
+    export PATH="$BIN_DIR:$PATH"
+fi
+
+CONFIG_DIR="$HOME/.config/hf-save"
+mkdir -p "$CONFIG_DIR"
+if [ -z "$TOKEN" ]; then
+    read -p "Enter your HF_SAVE_API_KEY (Pre-shared API Key): " TOKEN
+fi
+cat << EOF > "$CONFIG_DIR/config.json"
+{
+  "server_url": "$SERVER_URL",
+  "api_key": "$TOKEN"
+}
+EOF
+echo "Installation successful! Try running: hf-save --help (Or reload your shell profile)"
+`, serverURL, token)
+		w.Write([]byte(script))
+
+	default: // Default to linux
+		script := fmt.Sprintf(`#!/bin/bash
+set -e
+SERVER_URL="%s"
+TOKEN="%s"
+BIN_DIR="$HOME/.local/bin"
+mkdir -p "$BIN_DIR"
+# Determine CPU architecture
+ARCH="amd64"
+if [[ "$(uname -m)" == "aarch64" ]]; then
+    ARCH="arm64"
+fi
+echo "Downloading hf-save CLI for Linux ($ARCH)..."
+curl -fsSL "$SERVER_URL/bin/linux-$ARCH" -o "$BIN_DIR/hf-save"
+chmod +x "$BIN_DIR/hf-save"
+
+# Add to path helper
+if [[ ":$PATH:" != *":$BIN_DIR:"* ]]; then
+    echo "Adding $BIN_DIR to PATH in shell profile..."
+    echo 'export PATH="$HOME/.local/bin:$PATH"' >> "$HOME/.bashrc"
+    export PATH="$BIN_DIR:$PATH"
+fi
+
+CONFIG_DIR="$HOME/.config/hf-save"
+mkdir -p "$CONFIG_DIR"
+if [ -z "$TOKEN" ]; then
+    read -p "Enter your HF_SAVE_API_KEY (Pre-shared API Key): " TOKEN
+fi
+cat << EOF > "$CONFIG_DIR/config.json"
+{
+  "server_url": "$SERVER_URL",
+  "api_key": "$TOKEN"
+}
+EOF
+echo "Installation successful! Try running: hf-save --help (Or run: export PATH=\$HOME/.local/bin:\$PATH)"
+`, serverURL, token)
+		w.Write([]byte(script))
+	}
+}
+
+// Serves compiled CLI binaries
+func handleServeBinaries(w http.ResponseWriter, r *http.Request) {
+	filename := strings.TrimPrefix(r.URL.Path, "/bin/")
+	if filename == "" {
+		http.Error(w, "Not Found", http.StatusNotFound)
+		return
+	}
+
+	// Sanitize filename
+	filename = filepath.Base(filename)
+	binaryPath := filepath.Join(binDir, filename)
+
+	if _, err := os.Stat(binaryPath); os.IsNotExist(err) {
+		// Fallback for names containing extensions like .exe
+		if strings.HasSuffix(filename, ".exe") {
+			binaryPath = filepath.Join(binDir, "windows-amd64")
+		} else if strings.Contains(filename, "linux") {
+			binaryPath = filepath.Join(binDir, "linux-amd64")
+		} else if strings.Contains(filename, "mac") || strings.Contains(filename, "darwin") {
+			binaryPath = filepath.Join(binDir, "darwin-amd64")
+		}
+	}
+
+	if _, err := os.Stat(binaryPath); os.IsNotExist(err) {
+		http.Error(w, "Binary not found on server", http.StatusNotFound)
+		return
+	}
+
+	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%s", filename))
+	w.Header().Set("Content-Type", "application/octet-stream")
+	http.ServeFile(w, r, binaryPath)
+}
+
+// Handles multipart file uploads (Streams files straight to directory structure)
+func handleUpload(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	mr, err := r.MultipartReader()
+	if err != nil {
+		http.Error(w, fmt.Sprintf("Failed to read multipart data: %v", err), http.StatusBadRequest)
+		return
+	}
+
+	var currentPrefix string
+	fileCount := 0
+
+	for {
+		part, err := mr.NextPart()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			http.Error(w, fmt.Sprintf("Error parsing part: %v", err), http.StatusInternalServerError)
+			return
+		}
+
+		formName := part.FormName()
+
+		if formName == "prefix" {
+			prefixVal, err := io.ReadAll(part)
+			if err != nil {
+				http.Error(w, "Failed to read prefix", http.StatusBadRequest)
+				return
+			}
+			currentPrefix = string(prefixVal)
+			part.Close()
+			continue
+		}
+
+		if formName == "files" {
+			if currentPrefix == "" {
+				// Fallback to today's date if prefix wasn't provided first
+				currentPrefix = time.Now().Format("2006-01-02/15-04-05_upload")
+			}
+
+			// Clean prefix
+			cleanPrefix := filepath.Clean(currentPrefix)
+			// Prevent directory traversal attacks
+			if strings.Contains(cleanPrefix, "..") || strings.HasPrefix(cleanPrefix, "/") {
+				http.Error(w, "Invalid prefix path", http.StatusBadRequest)
+				return
+			}
+
+			// The file's relative path is stored in the header's filename
+			relPath := part.FileName()
+			if relPath == "" {
+				part.Close()
+				continue
+			}
+
+			// Clean and resolve local target path
+			cleanRelPath := filepath.Clean(relPath)
+			if strings.Contains(cleanRelPath, "..") || strings.HasPrefix(cleanRelPath, "/") {
+				part.Close()
+				continue
+			}
+
+			targetPath := filepath.Join(dataDir, cleanPrefix, cleanRelPath)
+			targetDir := filepath.Dir(targetPath)
+
+			if err := os.MkdirAll(targetDir, 0755); err != nil {
+				http.Error(w, fmt.Sprintf("Failed to create target directory: %v", err), http.StatusInternalServerError)
+				return
+			}
+
+			dst, err := os.Create(targetPath)
+			if err != nil {
+				http.Error(w, fmt.Sprintf("Failed to create file: %v", err), http.StatusInternalServerError)
+				return
+			}
+
+			if _, err := io.Copy(dst, part); err != nil {
+				dst.Close()
+				http.Error(w, fmt.Sprintf("Failed to save file: %v", err), http.StatusInternalServerError)
+				return
+			}
+			dst.Close()
+			part.Close()
+			fileCount++
+		}
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"success":    true,
+		"file_count": fileCount,
+		"prefix":     currentPrefix,
+	})
+}
+
+// Lists dates or runs within a date
+func handleList(w http.ResponseWriter, r *http.Request) {
+	dateParam := r.URL.Query().Get("date")
+
+	var results []string
+
+	if dateParam == "" {
+		// List top-level date directories
+		entries, err := os.ReadDir(dataDir)
+		if err != nil {
+			http.Error(w, fmt.Sprintf("Failed to read data directory: %v", err), http.StatusInternalServerError)
+			return
+		}
+		for _, entry := range entries {
+			if entry.IsDir() {
+				// Basic check for YYYY-MM-DD pattern
+				name := entry.Name()
+				if len(name) == 10 && name[4] == '-' && name[7] == '-' {
+					results = append(results, name)
+				}
+			}
+		}
+	} else {
+		// List upload runs inside the specified date
+		cleanDate := filepath.Clean(dateParam)
+		if strings.Contains(cleanDate, "..") || strings.HasPrefix(cleanDate, "/") {
+			http.Error(w, "Invalid date format", http.StatusBadRequest)
+			return
+		}
+
+		targetPath := filepath.Join(dataDir, cleanDate)
+		entries, err := os.ReadDir(targetPath)
+		if err != nil {
+			if os.IsNotExist(err) {
+				w.Header().Set("Content-Type", "application/json")
+				json.NewEncoder(w).Encode([]string{})
+				return
+			}
+			http.Error(w, fmt.Sprintf("Failed to read date directory: %v", err), http.StatusInternalServerError)
+			return
+		}
+
+		for _, entry := range entries {
+			if entry.IsDir() {
+				results = append(results, entry.Name())
+			}
+		}
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(results)
+}
+
+// Download file stream or metadata list
+func handleDownload(w http.ResponseWriter, r *http.Request) {
+	filePath := r.URL.Query().Get("file")
+	snapshotPath := r.URL.Query().Get("snapshot")
+
+	if filePath != "" {
+		// Stream a specific file
+		cleanPath := filepath.Clean(filePath)
+		if strings.Contains(cleanPath, "..") || strings.HasPrefix(cleanPath, "/") {
+			http.Error(w, "Invalid file path", http.StatusBadRequest)
+			return
+		}
+
+		fullPath := filepath.Join(dataDir, cleanPath)
+		if _, err := os.Stat(fullPath); os.IsNotExist(err) {
+			http.Error(w, "File not found", http.StatusNotFound)
+			return
+		}
+
+		w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%s", filepath.Base(fullPath)))
+		w.Header().Set("Content-Type", "application/octet-stream")
+		http.ServeFile(w, r, fullPath)
+		return
+	}
+
+	if snapshotPath != "" {
+		// List all files within a snapshot to download
+		cleanSnapshot := filepath.Clean(snapshotPath)
+		if strings.Contains(cleanSnapshot, "..") || strings.HasPrefix(cleanSnapshot, "/") {
+			http.Error(w, "Invalid snapshot path", http.StatusBadRequest)
+			return
+		}
+
+		fullDir := filepath.Join(dataDir, cleanSnapshot)
+		var files []string
+
+		err := filepath.Walk(fullDir, func(path string, info os.FileInfo, err error) error {
+			if err != nil {
+				return err
+			}
+			if !info.IsDir() {
+				rel, err := filepath.Rel(fullDir, path)
+				if err == nil {
+					// Convert windows backslashes to slash for web transport compatibility
+					files = append(files, filepath.ToSlash(rel))
+				}
+			}
+			return nil
+		})
+
+		if err != nil {
+			if os.IsNotExist(err) {
+				http.Error(w, "Snapshot not found", http.StatusNotFound)
+				return
+			}
+			http.Error(w, fmt.Sprintf("Failed to scan snapshot: %v", err), http.StatusInternalServerError)
+			return
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(files)
+		return
+	}
+
+	http.Error(w, "Missing query parameter 'file' or 'snapshot'", http.StatusBadRequest)
+}