Use Patch-* as header prefix

Author: tionis

README.md

@@ -149,21 +149,21 @@ curl https://patchwork.example.com/public/./notifications?pubsub=true -d "broadc
 
 ## Passthrough Headers
 
-Patchwork supports passthrough headers using the `PH-*` prefix system, allowing you to forward original request context between clients through the relay system.
+Patchwork supports passthrough headers using the `Patch-H-*` prefix system, allowing you to forward original request context between clients through the relay system.
 
 ### How It Works
 
-- **Request Headers**: Headers starting with `PH-` represent original headers from the requester
-- **Response Headers**: `PH-*` headers are stripped of their prefix and passed through to the final receiver
-- **Automatic Headers**: Common headers like `User-Agent`, `Accept`, etc. are automatically converted to `PH-*` format
+- **Request Headers**: Headers starting with `Patch-H-` represent original headers from the requester
+- **Response Headers**: `Patch-H-*` headers are stripped of their prefix and passed through to the final receiver
+- **Automatic Headers**: Common headers like `User-Agent`, `Accept`, etc. are automatically converted to `Patch-H-*` format
 
 ### Example Usage
 
 **Producer side** (sending headers):
 ```bash
 curl -X POST \
-  -H "PH-Original-IP: 192.168.1.100" \
-  -H "PH-User-ID: alice123" \
+  -H "Patch-H-Original-IP: 192.168.1.100" \
+  -H "Patch-H-User-ID: alice123" \
   -H "User-Agent: MyApp/1.0" \
   -d "request data" \
   https://patchwork.example.com/public/queue/api
@@ -328,8 +328,8 @@ curl https://patchwork.example.com/public/./alerts?pubsub=true -d "system-update
 ```bash
 # Send with context headers
 curl -X POST \
-  -H "PH-Client-IP: 10.0.1.5" \
-  -H "PH-Trace-ID: req-12345" \
+  -H "Patch-H-Client-IP: 10.0.1.5" \
+  -H "Patch-H-Trace-ID: req-12345" \
   -d "api-request" \
   https://patchwork.example.com/public/queue/api
 

assets/index.html

@@ -94,20 +94,20 @@ <h3>Flexible Behavior</h3>
 curl {{.BaseURL}}/public/./notifications?pubsub=true -d "broadcast"</pre>
 
   <h2>Passthrough Headers</h2>
-  <p>Patchwork supports passthrough headers using the <code>PH-*</code> prefix system, allowing you to forward original request context between clients through the relay system.</p>
+  <p>Patchwork supports passthrough headers using the <code>Patch-H-*</code> prefix system, allowing you to forward original request context between clients through the relay system.</p>
 
   <h3>How It Works</h3>
   <ul>
-    <li><strong>Request Headers:</strong> Headers starting with <code>PH-</code> represent original headers from the requester</li>
-    <li><strong>Response Headers:</strong> <code>PH-*</code> headers are stripped of their prefix and passed through to the final receiver</li>
-    <li><strong>Automatic Headers:</strong> Common headers like <code>User-Agent</code>, <code>Accept</code>, etc. are automatically converted to <code>PH-*</code> format</li>
+    <li><strong>Request Headers:</strong> Headers starting with <code>Patch-H-</code> represent original headers from the requester</li>
+    <li><strong>Response Headers:</strong> <code>Patch-H-*</code> headers are stripped of their prefix and passed through to the final receiver</li>
+    <li><strong>Automatic Headers:</strong> Common headers like <code>User-Agent</code>, <code>Accept</code>, etc. are automatically converted to <code>Patch-H-*</code> format</li>
   </ul>
 
   <h3>Example Usage</h3>
   <p><strong>Producer side</strong> (sending headers):</p>
   <pre>curl -X POST \
-  -H "PH-Original-IP: 192.168.1.100" \
-  -H "PH-User-ID: alice123" \
+  -H "Patch-H-Original-IP: 192.168.1.100" \
+  -H "Patch-H-User-ID: alice123" \
   -H "User-Agent: MyApp/1.0" \
   -d "request data" \
   {{.BaseURL}}/public/queue/api</pre>
@@ -274,8 +274,8 @@ <h3>Namespace Behavior Examples</h3>
   <p><strong>Using passthrough headers</strong>:</p>
   <pre># Send with context headers
 curl -X POST \
-  -H "PH-Client-IP: 10.0.1.5" \
-  -H "PH-Trace-ID: req-12345" \
+  -H "Patch-H-Client-IP: 10.0.1.5" \
+  -H "Patch-H-Trace-ID: req-12345" \
   -d "api-request" \
   {{.BaseURL}}/public/queue/api
 

main.go

@@ -607,13 +607,13 @@ func (s *server) publicHandler(w http.ResponseWriter, r *http.Request) {
 	path := vars["path"]
 
 	s.logRequest(r, "Public namespace access")
-	
+
 	// Determine namespace based on request path
 	namespace := "p" // default for backward compatibility
 	if strings.HasPrefix(r.URL.Path, "/public/") {
 		namespace = "public"
 	}
-	
+
 	s.handlePatch(w, r, namespace, "", path)
 }
 
@@ -1145,66 +1145,66 @@ const (
 func determinePathBehavior(path string, hasQueueParam bool) PathBehavior {
 	// Remove leading slash for consistent checking
 	cleanPath := strings.TrimPrefix(path, "/")
-	
+
 	// Check for special control endpoints
 	if strings.HasPrefix(cleanPath, "_/") {
 		return BehaviorSpecial
 	}
-	
+
 	// Check for explicit pubsub namespace
 	if strings.HasPrefix(cleanPath, "pubsub/") {
 		return BehaviorPubsub
 	}
-	
+
 	// Check for explicit queue namespace
 	if strings.HasPrefix(cleanPath, "queue/") {
 		return BehaviorBlocking
 	}
-	
+
 	// For flexible space (/./...), check query parameter
 	if strings.HasPrefix(cleanPath, "./") {
 		if hasQueueParam {
 			return BehaviorPubsub
 		}
 		return BehaviorBlocking
 	}
-	
+
 	// Default to blocking behavior
 	return BehaviorBlocking
 }
 
-// processPassthroughHeaders handles PH-* headers for request/response
+// processPassthroughHeaders handles Patch-H-* headers for request/response
 func processPassthroughHeaders(headers http.Header, isRequest bool) map[string]string {
 	processed := make(map[string]string)
-	
+
 	for key, values := range headers {
-		if strings.HasPrefix(key, "PH-") {
+		if strings.HasPrefix(key, "Patch-H-") {
 			if isRequest {
-				// For requests: PH-* headers represent original headers from requester
-				// Strip PH- prefix for the responder
-				originalKey := strings.TrimPrefix(key, "PH-")
+				// For requests: Patch-H-* headers represent original headers from requester
+				// Strip Patch-H- prefix for the responder
+				originalKey := strings.TrimPrefix(key, "Patch-H-")
 				if len(values) > 0 {
 					processed[originalKey] = values[0]
 				}
 			} else {
-				// For responses: PH-* headers should be stripped and passed through
-				originalKey := strings.TrimPrefix(key, "PH-")
+				// For responses: Patch-H-* headers should be stripped and passed through
+				originalKey := strings.TrimPrefix(key, "Patch-H-")
 				if len(values) > 0 {
 					processed[originalKey] = values[0]
 				}
 			}
 		}
 	}
-	
+
 	return processed
 }
 
-// addPassthroughHeaders adds headers to the response, handling PH-* passthrough
+// addPassthroughHeaders adds headers to the response, handling Patch-H-* passthrough
 func addPassthroughHeaders(w http.ResponseWriter, streamHeaders map[string]string) {
 	for key, value := range streamHeaders {
-		if strings.HasPrefix(key, "PH-") {
-			// Strip PH- prefix and add as regular header
-			originalKey := strings.TrimPrefix(key, "PH-")
+		if strings.HasPrefix(key, "Patch-H-") {
+			// Strip Patch-H- prefix and add as regular header
+			originalKey := strings.TrimPrefix(key, "Patch-H-")
 			w.Header().Set(originalKey, value)
 		} else {
 			// Regular headers pass through as-is
@@ -1213,38 +1213,38 @@ func addPassthroughHeaders(w http.ResponseWriter, streamHeaders map[string]strin
 	}
 }
 
-// prepareRequestHeaders prepares headers for the stream, adding PH-* prefixes for passthrough
+// prepareRequestHeaders prepares headers for the stream, adding Patch-H-* prefixes for passthrough
 func prepareRequestHeaders(r *http.Request) map[string]string {
 	headers := make(map[string]string)
-	
+
 	// Add content type if present
 	contentType := r.Header.Get("Content-Type")
 	if contentType != "" {
 		headers["Content-Type"] = contentType
 	} else {
 		headers["Content-Type"] = "text/plain"
 	}
-	
-	// Process passthrough headers (add PH- prefix to headers that should be passed through)
+
+	// Process passthrough headers (add Patch-H-* prefix to headers that should be passed through)
 	// For now, we'll pass through common headers like User-Agent, Accept, etc.
 	passthroughCandidates := []string{
 		"User-Agent", "Accept", "Accept-Language", "Accept-Encoding",
 		"Referer", "Origin", "X-Forwarded-For", "X-Real-IP",
 	}
-	
+
 	for _, headerName := range passthroughCandidates {
 		if value := r.Header.Get(headerName); value != "" {
-			headers["PH-"+headerName] = value
+			headers["Patch-H-"+headerName] = value
 		}
 	}
-	
-	// Also add any explicit PH-* headers from the request
+
+	// Also add any explicit Patch-H-* headers from the request
 	for key, values := range r.Header {
-		if strings.HasPrefix(key, "PH-") && len(values) > 0 {
+		if strings.HasPrefix(key, "Patch-H-") && len(values) > 0 {
 			headers[key] = values[0]
 		}
 	}
-	
+
 	return headers
 }
 
@@ -1357,7 +1357,7 @@ func (s *server) handlePatch(
 
 	// Determine behavior based on path structure and query params
 	// (queries, hasPubsubParam, and behavior already defined above)
-	
+
 	// For backward compatibility, also check the old pubsub query parameter
 	_, pubsub := queries["pubsub"]
 	if behavior == BehaviorPubsub || pubsub {
@@ -1851,19 +1851,19 @@ func getHTTPServer(logger *slog.Logger, ctx context.Context, port int) *http.Ser
 	})
 
 	router.HandleFunc("/huproxy/{user}/{host}/{port}", huproxy.HuproxyHandler(server))
-	
-	// Public namespace with new structure  
+
+	// Public namespace with new structure
 	router.HandleFunc("/public/{path:.*}", server.publicHandler)
-	
+
 	// Backward compatibility - old /p/ routes map to /public/
 	router.HandleFunc("/p/{path:.*}", server.publicHandler)
-	
+
 	// Hook namespaces (unchanged)
 	router.HandleFunc("/h", server.forwardHookRootHandler)
 	router.HandleFunc("/h/{path:.*}", server.forwardHookHandler)
 	router.HandleFunc("/r", server.reverseHookRootHandler)
 	router.HandleFunc("/r/{path:.*}", server.reverseHookHandler)
-	
+
 	// User namespaces with new structure
 	router.HandleFunc("/u/{username}/_/ntfy", server.userNtfyHandler)
 	router.HandleFunc("/u/{username}/_/{adminPath:.*}", server.userAdminHandler)