moderation: ozone proxy experiment

go.mod

···
 
 replace github.com/AxisCommunications/go-dpop => github.com/streamplace/go-dpop v0.0.0-20250510031900-c897158a8ad4
 
+replace github.com/streamplace/oatproxy => ../oatproxy
+
 require (
 	firebase.google.com/go/v4 v4.14.1
 	git.stream.place/streamplace/c2pa-go v0.7.0
···
 	github.com/johncgriffin/overflow v0.0.0-20211019200055-46fa312c352c
 	github.com/julienschmidt/httprouter v1.3.0
 	github.com/labstack/echo/v4 v4.13.3
+	github.com/labstack/gommon v0.4.2
 	github.com/lestrrat-go/jwx/v2 v2.1.6
 	github.com/livepeer/lpms v0.0.0-20240812093642-b5181eb92cb2
 	github.com/lmittmann/tint v1.1.0
···
 	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
 	github.com/kulti/thelper v0.6.3 // indirect
 	github.com/kunwardeep/paralleltest v1.0.14 // indirect
-	github.com/labstack/gommon v0.4.2 // indirect
 	github.com/lasiar/canonicalheader v1.1.2 // indirect
 	github.com/ldez/exptostd v0.4.3 // indirect
 	github.com/ldez/gomoddirectives v0.6.1 // indirect

go.sum

···
 github.com/streamplace/atproto-oauth-golang v0.0.0-20250619231223-a9c04fb888ac/go.mod h1:9LlKkqciiO5lRfbX0n4Wn5KNY9nvFb4R3by8FdW2TWc=
 github.com/streamplace/go-dpop v0.0.0-20250510031900-c897158a8ad4 h1:L1fS4HJSaAyNnkwfuZubgfeZy8rkWmA0cMtH5Z0HqNc=
 github.com/streamplace/go-dpop v0.0.0-20250510031900-c897158a8ad4/go.mod h1:bGUXY9Wd4mnd+XUrOYZr358J2f6z9QO/dLhL1SsiD+0=
-github.com/streamplace/oatproxy v0.0.0-20250619231549-b15df1b82a3a h1:rbfSEm9IgK6jhXXtOExexL+ACNDOE/zJ5VYp6ujTpCA=
-github.com/streamplace/oatproxy v0.0.0-20250619231549-b15df1b82a3a/go.mod h1:pXi24hA7xBHj8eEywX6wGqJOR9FaEYlGwQ/72rN6okw=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=

pkg/spxrpc/com_atproto_moderation.go

···
 package spxrpc
 
 import (
+	"bytes"
 	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
 
 	comatprototypes "github.com/bluesky-social/indigo/api/atproto"
+	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/labstack/echo/v4"
+	"github.com/streamplace/oatproxy/pkg/oatproxy"
+	"stream.place/streamplace/pkg/aqhttp"
+	"stream.place/streamplace/pkg/log"
 )
 
 func (s *Server) handleComAtprotoModerationCreateReport(ctx context.Context, body *comatprototypes.ModerationCreateReport_Input) (*comatprototypes.ModerationCreateReport_Output, error) {
-	panic("not implemented")
+	c, ok := ctx.Value(echoContextKey).(echo.Context)
+	if !ok {
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, "echo context not found")
+	}
+
+	dPoP := c.Request().Header.Get("DPoP")
+	if dPoP == "" {
+		return s.handleComAtprotoModerationCreateReportToOzone(ctx, c, body)
+	} else {
+		return s.handleComAtprotoModerationCreateReportToPDS(ctx, c, body)
+	}
+}
+
+func (s *Server) handleComAtprotoModerationCreateReportToOzone(ctx context.Context, c echo.Context, body *comatprototypes.ModerationCreateReport_Input) (*comatprototypes.ModerationCreateReport_Output, error) {
+	// Serialize the input body to JSON
+	jsonBody, err := json.Marshal(body)
+	if err != nil {
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("failed to marshal request body: %v", err))
+	}
+
+	// Create the request URL
+	url := fmt.Sprintf("%s/xrpc/com.atproto.moderation.createReport", s.cli.OzoneURL)
+
+	// Create the HTTP request
+	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(jsonBody))
+	if err != nil {
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("failed to create request: %v", err))
+	}
+
+	authorization := c.Request().Header.Get("Authorization")
+	if authorization == "" {
+		return nil, echo.NewHTTPError(http.StatusUnauthorized, "Authorization header not found")
+	}
+
+	log.Log(ctx, "handleComAtprotoModerationCreateReportToOzone", "authorization", authorization)
+
+	// Set headers
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", authorization)
+
+	// Send the request
+	resp, err := aqhttp.Client.Do(req)
+	if err != nil {
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("failed to send request: %v", err))
+	}
+	defer resp.Body.Close()
+
+	// Read the response body
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("failed to read response body: %v", err))
+	}
+
+	// Check if the response was successful
+	if resp.StatusCode != http.StatusOK {
+		return nil, echo.NewHTTPError(resp.StatusCode, fmt.Sprintf("upstream error: %s", string(respBody)))
+	}
+
+	// Deserialize the response
+	var output comatprototypes.ModerationCreateReport_Output
+	if err := json.Unmarshal(respBody, &output); err != nil {
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("failed to unmarshal response: %v", err))
+	}
+
+	return &output, nil
+}
+
+func (s *Server) handleComAtprotoModerationCreateReportToPDS(ctx context.Context, c echo.Context, body *comatprototypes.ModerationCreateReport_Input) (*comatprototypes.ModerationCreateReport_Output, error) {
+	log.Log(ctx, "handleComAtprotoModerationCreateReport", "body", body)
+	if s.cli.OzoneURL == "" {
+		return nil, echo.NewHTTPError(http.StatusNotImplemented, "Ozone URL is not set")
+	}
+
+	session, client := oatproxy.GetOAuthSession(ctx)
+	if session == nil {
+		return nil, echo.NewHTTPError(http.StatusUnauthorized, "oauth session not found")
+	}
+
+	client.SetHeaders(map[string]string{
+		"Atproto-Proxy": fmt.Sprintf("%s#atproto_labeler", s.cli.MyDID()),
+	})
+
+	var output comatprototypes.ModerationCreateReport_Output
+	err := client.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.moderation.createReport", nil, body, &output)
+	if err != nil {
+		return nil, echo.NewHTTPError(http.StatusInternalServerError, err.Error())
+	}
+
+	return &output, nil
 }

pkg/spxrpc/spxrpc.go

···
 		model: model,
 	}
 	e.Use(s.ErrorHandlingMiddleware())
+	e.Use(s.ContextPreservingMiddleware())
 	e.Use(echomiddleware.Handler("", mdlw))
 	e.Use(op.OAuthMiddleware)
 	err := s.RegisterHandlersPlaceStream(e)
···
 		}
 	}
 }
+
+// unique type to prevent assignment.
+type echoContextKeyType struct{}
+
+// singleton value to identify our logging metadata in context
+var echoContextKey = echoContextKeyType{}
+
+func (s *Server) ContextPreservingMiddleware() echo.MiddlewareFunc {
+	return func(next echo.HandlerFunc) echo.HandlerFunc {
+		return func(c echo.Context) error {
+			ctx := c.Request().Context()
+			if ctx == nil {
+				ctx = context.Background()
+			}
+			ctx = context.WithValue(ctx, echoContextKey, c)
+			c.SetRequest(c.Request().WithContext(ctx))
+			return next(c)
+		}
+	}
+}