webapi: remove dead code and collapse lifestream stub routes

server/webapi/handlers/amf_encoder_test.go

@@ -239,7 +239,7 @@ func TestSendAMF(t *testing.T) {
 			}
 
 			w := httptest.NewRecorder()
-			SendAMF(w, tt.request, tt.data, nil)
+			sendAMF(w, tt.request, tt.data, nil)
 
 			resp := w.Result()
 			if resp.StatusCode != tt.expectStatus {

server/webapi/handlers/common.go

@@ -10,21 +10,8 @@ import (
 	"net/http"
 	"strconv"
 	"strings"
-
-	"github.com/mk6i/open-oscar-server/state"
 )
 
-// SessionRetriever provides methods to retrieve OSCAR sessions.
-type SessionRetriever interface {
-	AllSessions() []*state.Session
-	RetrieveSession(screenName state.IdentScreenName) *state.Session
-}
-
-// CommonHandler provides shared utilities for all Web API handlers.
-type CommonHandler struct {
-	Logger *slog.Logger
-}
-
 // BaseResponse is the standard response envelope for all Web API responses.
 // It supports both JSON and XML marshaling.
 type BaseResponse struct {
@@ -118,20 +105,20 @@ func SendResponse(w http.ResponseWriter, r *http.Request, data interface{}, logg
 	// Check for format parameter (f for format or callback for JSONP)
 	// First check URL query parameters
 	format := strings.ToLower(r.URL.Query().Get("f"))
-	callback := JSONPCallback(r)
+	callback := jsonpCallback(r)
 
 	// If format not in URL query, check form values (for POST requests)
 	if format == "" && r.Method == "POST" {
 		_ = r.ParseForm()
 		format = strings.ToLower(r.FormValue("f"))
 		if callback == "" {
-			callback = JSONPCallback(r)
+			callback = jsonpCallback(r)
 		}
 	}
 
 	// Check for AMF format first
 	if format == "amf" || format == "amf3" {
-		SendAMF(w, r, data, logger)
+		sendAMF(w, r, data, logger)
 		return
 	}
 
@@ -139,24 +126,24 @@ func SendResponse(w http.ResponseWriter, r *http.Request, data interface{}, logg
 	accept := strings.ToLower(r.Header.Get("Accept"))
 	if strings.Contains(accept, "application/x-amf") ||
 		strings.Contains(accept, "application/amf") {
-		SendAMF(w, r, data, logger)
+		sendAMF(w, r, data, logger)
 		return
 	}
 
 	// If callback is provided, it's JSONP
 	if callback != "" {
-		SendJSONP(w, callback, data, logger)
+		sendJSONP(w, callback, data, logger)
 		return
 	}
 
 	// Check for XML format
 	if format == "xml" {
-		SendXML(w, data, logger)
+		sendXML(w, data, logger)
 		return
 	}
 
 	// Default to JSON
-	SendJSON(w, data, logger)
+	sendJSON(w, data, logger)
 }
 
 // SendError sends an error response in the appropriate format.
@@ -165,16 +152,16 @@ func SendError(w http.ResponseWriter, statusCode int, message string) {
 	contentType := w.Header().Get("Content-Type")
 
 	if strings.Contains(contentType, "amf") {
-		SendAMFError(w, nil, statusCode, message, nil)
+		sendAMFError(w, nil, statusCode, message, nil)
 	} else if strings.Contains(contentType, "xml") {
-		SendXMLError(w, statusCode, message)
+		sendXMLError(w, statusCode, message)
 	} else {
-		SendJSONError(w, statusCode, message)
+		sendJSONError(w, statusCode, message)
 	}
 }
 
-// SendJSONError sends a JSON error response.
-func SendJSONError(w http.ResponseWriter, statusCode int, message string) {
+// sendJSONError sends a JSON error response.
+func sendJSONError(w http.ResponseWriter, statusCode int, message string) {
 	resp := ErrorResponse{}
 	resp.Response.StatusCode = statusCode
 	resp.Response.StatusText = message
@@ -184,8 +171,8 @@ func SendJSONError(w http.ResponseWriter, statusCode int, message string) {
 	_ = json.NewEncoder(w).Encode(resp)
 }
 
-// SendXMLError sends an XML error response.
-func SendXMLError(w http.ResponseWriter, statusCode int, message string) {
+// sendXMLError sends an XML error response.
+func sendXMLError(w http.ResponseWriter, statusCode int, message string) {
 	resp := ErrorResponse{}
 	resp.StatusCode = statusCode
 	resp.StatusText = message
@@ -205,8 +192,8 @@ func SendXMLError(w http.ResponseWriter, statusCode int, message string) {
 	_, _ = w.Write([]byte(xmlOutput))
 }
 
-// SendJSON sends a JSON response.
-func SendJSON(w http.ResponseWriter, data interface{}, logger *slog.Logger) {
+// sendJSON sends a JSON response.
+func sendJSON(w http.ResponseWriter, data interface{}, logger *slog.Logger) {
 	w.Header().Set("Content-Type", "application/json")
 	body, err := json.Marshal(data)
 	if err != nil {
@@ -223,8 +210,8 @@ func SendJSON(w http.ResponseWriter, data interface{}, logger *slog.Logger) {
 	}
 }
 
-// SendXML sends an XML response.
-func SendXML(w http.ResponseWriter, data interface{}, logger *slog.Logger) {
+// sendXML sends an XML response.
+func sendXML(w http.ResponseWriter, data interface{}, logger *slog.Logger) {
 	w.Header().Set("Content-Type", "text/xml; charset=utf-8")
 
 	// Convert BaseResponse with map data to a format XML can handle
@@ -238,7 +225,7 @@ func SendXML(w http.ResponseWriter, data interface{}, logger *slog.Logger) {
 		if logger != nil {
 			logger.Error("failed to marshal XML response", "err", err.Error())
 		}
-		SendXMLError(w, http.StatusInternalServerError, "internal server error")
+		sendXMLError(w, http.StatusInternalServerError, "internal server error")
 		return
 	}
 
@@ -250,20 +237,20 @@ func SendXML(w http.ResponseWriter, data interface{}, logger *slog.Logger) {
 	_, _ = w.Write([]byte(xmlOutput))
 }
 
-// JSONPCallback returns the JSONP callback name from the request.
+// jsonpCallback returns the JSONP callback name from the request.
 // Web AIM clients use the "c" query parameter; other callers may use "callback".
-func JSONPCallback(r *http.Request) string {
+func jsonpCallback(r *http.Request) string {
 	if callback := r.URL.Query().Get("c"); callback != "" {
 		return callback
 	}
 	return r.URL.Query().Get("callback")
 }
 
-// SendJSONP sends a JSONP response with the specified callback.
-func SendJSONP(w http.ResponseWriter, callback string, data interface{}, logger *slog.Logger) {
+// sendJSONP sends a JSONP response with the specified callback.
+func sendJSONP(w http.ResponseWriter, callback string, data interface{}, logger *slog.Logger) {
 	// Validate callback to prevent XSS
-	if !IsValidCallback(callback) {
-		SendJSONError(w, http.StatusBadRequest, "invalid callback parameter")
+	if !isValidCallback(callback) {
+		sendJSONError(w, http.StatusBadRequest, "invalid callback parameter")
 		return
 	}
 
@@ -272,7 +259,7 @@ func SendJSONP(w http.ResponseWriter, callback string, data interface{}, logger
 		if logger != nil {
 			logger.Error("failed to marshal response", "err", err.Error())
 		}
-		SendJSONError(w, http.StatusInternalServerError, "internal server error")
+		sendJSONError(w, http.StatusInternalServerError, "internal server error")
 		return
 	}
 
@@ -283,8 +270,8 @@ func SendJSONP(w http.ResponseWriter, callback string, data interface{}, logger
 	_, _ = w.Write([]byte(");"))
 }
 
-// IsValidCallback validates a JSONP callback name to prevent XSS.
-func IsValidCallback(callback string) bool {
+// isValidCallback validates a JSONP callback name to prevent XSS.
+func isValidCallback(callback string) bool {
 	if len(callback) == 0 || len(callback) > 100 {
 		return false
 	}
@@ -302,8 +289,8 @@ func IsValidCallback(callback string) bool {
 	return true
 }
 
-// SendAMF sends an AMF response
-func SendAMF(w http.ResponseWriter, r *http.Request, data interface{}, logger *slog.Logger) {
+// sendAMF sends an AMF response
+func sendAMF(w http.ResponseWriter, r *http.Request, data interface{}, logger *slog.Logger) {
 	encoder := NewAMFEncoder(logger)
 	version := DetectAMFVersion(r)
 
@@ -316,7 +303,7 @@ func SendAMF(w http.ResponseWriter, r *http.Request, data interface{}, logger *s
 				"dataType", fmt.Sprintf("%T", data))
 		}
 		// Fall back to JSON error
-		SendJSONError(w, http.StatusInternalServerError, "AMF encoding failed")
+		sendJSONError(w, http.StatusInternalServerError, "AMF encoding failed")
 		return
 	}
 
@@ -409,8 +396,8 @@ func convertBaseResponseForXML(resp BaseResponse) XMLMapResponse {
 	return xmlResp
 }
 
-// SendAMFError sends an AMF error response
-func SendAMFError(w http.ResponseWriter, r *http.Request, statusCode int, message string, logger *slog.Logger) {
+// sendAMFError sends an AMF error response
+func sendAMFError(w http.ResponseWriter, r *http.Request, statusCode int, message string, logger *slog.Logger) {
 	errorResp := ErrorResponse{}
 	errorResp.Response.StatusCode = statusCode
 	errorResp.Response.StatusText = message
@@ -421,7 +408,7 @@ func SendAMFError(w http.ResponseWriter, r *http.Request, statusCode int, messag
 	amfData, err := encoder.EncodeAMF(errorResp, version)
 	if err != nil {
 		// If AMF encoding fails, fall back to JSON error
-		SendJSONError(w, statusCode, message)
+		sendJSONError(w, statusCode, message)
 		return
 	}
 

server/webapi/handlers/mocks_test.go

@@ -9,27 +9,6 @@ import (
 	"github.com/mk6i/open-oscar-server/wire"
 )
 
-// MockSessionRetriever is a mock implementation of SessionRetriever
-type MockSessionRetriever struct {
-	mock.Mock
-}
-
-func (m *MockSessionRetriever) AllSessions() []*state.Session {
-	args := m.Called()
-	if sessions := args.Get(0); sessions != nil {
-		return sessions.([]*state.Session)
-	}
-	return nil
-}
-
-func (m *MockSessionRetriever) RetrieveSession(screenName state.IdentScreenName) *state.Session {
-	args := m.Called(screenName)
-	if session := args.Get(0); session != nil {
-		return session.(*state.Session)
-	}
-	return nil
-}
-
 // MockLocateService is a mock implementation of LocateService
 type MockLocateService struct {
 	mock.Mock

server/webapi/handlers/session.go

@@ -636,32 +636,6 @@ func (h *SessionHandler) EndSession(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	//// Clean up OSCAR session if present
-	//if session.OSCARSession != nil && h.OSCARSessionManager != nil {
-	//	// Broadcast departure to OSCAR clients
-	//	if h.BuddyBroadcaster != nil {
-	//		if err := h.BuddyBroadcaster.BroadcastBuddyDeparted(ctx, session.OSCARSession.IdentScreenName()); err != nil {
-	//			h.Logger.ErrorContext(ctx, "failed to broadcast buddy departure", "err", err.Error())
-	//		}
-	//	}
-	//
-	//	// Unregister buddy list
-	//	if h.BuddyListRegistry != nil {
-	//		if err := h.BuddyListRegistry.UnregisterBuddyList(ctx, session.ScreenName.IdentScreenName()); err != nil {
-	//			h.Logger.ErrorContext(ctx, "failed to unregister buddy list", "err", err.Error())
-	//		}
-	//	}
-	//
-	//	h.OSCARSessionManager.RemoveSession(session.OSCARSession.Session())
-	//}
-	//
-	//// Remove session
-	//if err := h.SessionManager.RemoveSession(r.Context(), aimsid); err != nil {
-	//	h.Logger.ErrorContext(ctx, "failed to remove session", "err", err.Error())
-	//	h.sendError(w, r, http.StatusInternalServerError, "failed to end session")
-	//	return
-	//}
-
 	session.OSCARSession.CloseInstance()
 
 	// Send response

server/webapi/handlers/user_info_stub.go

@@ -9,10 +9,6 @@ type UserInfoStubHandler struct {
 	Logger *slog.Logger
 }
 
-func (h *UserInfoStubHandler) GetLocationsFollowing(w http.ResponseWriter, r *http.Request) {
-	h.emptyOK(w, r)
-}
-
 func (h *UserInfoStubHandler) GetUserDetails(w http.ResponseWriter, r *http.Request) {
 	resp := BaseResponse{}
 	resp.Response.StatusCode = 200

server/webapi/server.go

@@ -250,32 +250,11 @@ func NewServer(listeners []string, logger *slog.Logger, handler Handler, apiKeyV
 			return authMiddleware.AuthenticateFlexible(
 				authMiddleware.CORSMiddleware(http.HandlerFunc(h)))
 		}
+		// getUserDetails returns a minimal AIM identity. Every other lifestream/*
+		// method is an unimplemented social-feed feature; the subtree catch-all
+		// acknowledges them with an empty 200 so the client doesn't error.
 		mux.Handle("GET /lifestream/getUserDetails", lifestreamRoute(lifestreamStub.GetUserDetails))
-		mux.Handle("GET /lifestream/getLocationsFollowing", lifestreamRoute(lifestreamStub.GetLocationsFollowing))
-		for _, p := range []string{
-			"getAggregated",
-			"getNotifications",
-			"getSingle",
-			"getNotificationFilter",
-			"heyGetNotifications",
-			"heyMarkNotifications",
-			"deleteNotification",
-			"commonsFollow",
-			"commonsUnfollow",
-			"tdAddService",
-			"tdRemoveService",
-			"setUserPreference",
-			"getActivity",
-			"addComment",
-			"deleteComment",
-			"deleteActivity",
-			"addLike",
-			"deleteLike",
-			"setNotificationFilter",
-			"heyTakeAction",
-		} {
-			mux.Handle("GET /lifestream/"+p, lifestreamRoute(lifestreamStub.EmptyOK))
-		}
+		mux.Handle("GET /lifestream/", lifestreamRoute(lifestreamStub.EmptyOK))
 
 		// Unmatched paths (pattern "/" matches anything not covered by routes above).
 		mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {

server/webapi/types/events.go

@@ -79,13 +79,6 @@ type TypingEvent struct {
 	TypingStatus string `json:"typingStatus"`
 }
 
-// BuddyListEvent represents a buddy list change event.
-type BuddyListEvent struct {
-	Action string      `json:"action"` // "add", "remove", "update"
-	Buddy  interface{} `json:"buddy"`
-	Group  string      `json:"group,omitempty"`
-}
-
 // EventQueue manages a queue of events for a WebAPI session.
 type EventQueue struct {
 	events   []Event
@@ -214,22 +207,6 @@ func (q *EventQueue) GetAllEvents() []Event {
 	return result
 }
 
-// Clear removes all events from the queue.
-func (q *EventQueue) Clear() {
-	q.mu.Lock()
-	defer q.mu.Unlock()
-
-	q.events = make([]Event, 0)
-}
-
-// Size returns the current number of events in the queue.
-func (q *EventQueue) Size() int {
-	q.mu.RLock()
-	defer q.mu.RUnlock()
-
-	return len(q.events)
-}
-
 // Close closes the event queue, unblocking any waiting fetchers.
 func (q *EventQueue) Close() {
 	q.closedMu.Lock()
@@ -251,10 +228,3 @@ notifyWaiters:
 		}
 	}
 }
-
-// IsClosed returns whether the queue is closed.
-func (q *EventQueue) IsClosed() bool {
-	q.closedMu.RLock()
-	defer q.closedMu.RUnlock()
-	return q.closed
-}