core/server: refactory to use shared params/request structs

core/internal/server/apppicker/handlers.go

@@ -7,13 +7,7 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
 )
 
-type Request struct {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
-	ID     int            `json:"id"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params"`
-}
-
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	switch req.Method {
 	case "apppicker.open", "browser.open":
 		handleOpen(conn, req, manager)
@@ -22,7 +16,7 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleOpen(conn net.Conn, req Request, manager *Manager) {
+func handleOpen(conn net.Conn, req models.Request, manager *Manager) {
 	log.Infof("AppPicker: Received %s request with params: %+v", req.Method, req.Params)
 
 	target, ok := req.Params["target"].(string)

core/internal/server/bluez/handlers.go

@@ -6,25 +6,15 @@ import (
 	"net"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/params"
 )
 
-type Request struct {
-	ID     int            `json:"id,omitempty"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params,omitempty"`
-}
-
-type SuccessResult struct {
-	Success bool   `json:"success"`
-	Message string `json:"message"`
-}
-
 type BluetoothEvent struct {
 	Type string         `json:"type"`
 	Data BluetoothState `json:"data"`
 }
 
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 	switch req.Method {
 	case "bluetooth.getState":
 		handleGetState(conn, req, manager)
@@ -57,31 +47,30 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleGetState(conn net.Conn, req Request, manager *Manager) {
+func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
-	state := manager.GetState()
+	models.Respond(conn, req.ID, manager.GetState())
-	models.Respond(conn, req.ID, state)
 }
 
-func handleStartDiscovery(conn net.Conn, req Request, manager *Manager) {
+func handleStartDiscovery(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.StartDiscovery(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "discovery started"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "discovery started"})
 }
 
-func handleStopDiscovery(conn net.Conn, req Request, manager *Manager) {
+func handleStopDiscovery(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.StopDiscovery(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "discovery stopped"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "discovery stopped"})
 }
 
-func handleSetPowered(conn net.Conn, req Request, manager *Manager) {
+func handleSetPowered(conn net.Conn, req models.Request, manager *Manager) {
-	powered, ok := req.Params["powered"].(bool)
+	powered, err := params.Bool(req.Params, "powered")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'powered' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -90,13 +79,13 @@ func handleSetPowered(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "powered state updated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "powered state updated"})
 }
 
-func handlePairDevice(conn net.Conn, req Request, manager *Manager) {
+func handlePairDevice(conn net.Conn, req models.Request, manager *Manager) {
-	devicePath, ok := req.Params["device"].(string)
+	devicePath, err := params.String(req.Params, "device")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'device' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -105,13 +94,13 @@ func handlePairDevice(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "pairing initiated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "pairing initiated"})
 }
 
-func handleConnectDevice(conn net.Conn, req Request, manager *Manager) {
+func handleConnectDevice(conn net.Conn, req models.Request, manager *Manager) {
-	devicePath, ok := req.Params["device"].(string)
+	devicePath, err := params.String(req.Params, "device")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'device' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -120,13 +109,13 @@ func handleConnectDevice(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "connecting"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "connecting"})
 }
 
-func handleDisconnectDevice(conn net.Conn, req Request, manager *Manager) {
+func handleDisconnectDevice(conn net.Conn, req models.Request, manager *Manager) {
-	devicePath, ok := req.Params["device"].(string)
+	devicePath, err := params.String(req.Params, "device")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'device' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -135,13 +124,13 @@ func handleDisconnectDevice(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "disconnected"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "disconnected"})
 }
 
-func handleRemoveDevice(conn net.Conn, req Request, manager *Manager) {
+func handleRemoveDevice(conn net.Conn, req models.Request, manager *Manager) {
-	devicePath, ok := req.Params["device"].(string)
+	devicePath, err := params.String(req.Params, "device")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'device' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -150,13 +139,13 @@ func handleRemoveDevice(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "device removed"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "device removed"})
 }
 
-func handleTrustDevice(conn net.Conn, req Request, manager *Manager) {
+func handleTrustDevice(conn net.Conn, req models.Request, manager *Manager) {
-	devicePath, ok := req.Params["device"].(string)
+	devicePath, err := params.String(req.Params, "device")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'device' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -165,13 +154,13 @@ func handleTrustDevice(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "device trusted"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "device trusted"})
 }
 
-func handleUntrustDevice(conn net.Conn, req Request, manager *Manager) {
+func handleUntrustDevice(conn net.Conn, req models.Request, manager *Manager) {
-	devicePath, ok := req.Params["device"].(string)
+	devicePath, err := params.String(req.Params, "device")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'device' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -180,43 +169,31 @@ func handleUntrustDevice(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "device untrusted"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "device untrusted"})
 }
 
-func handlePairingSubmit(conn net.Conn, req Request, manager *Manager) {
+func handlePairingSubmit(conn net.Conn, req models.Request, manager *Manager) {
-	token, ok := req.Params["token"].(string)
+	token, err := params.String(req.Params, "token")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'token' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	secretsRaw, ok := req.Params["secrets"].(map[string]any)
+	secrets := params.StringMapOpt(req.Params, "secrets")
-	secrets := make(map[string]string)
+	accept := params.BoolOpt(req.Params, "accept", false)
-	if ok {
-		for k, v := range secretsRaw {
-			if str, ok := v.(string); ok {
-				secrets[k] = str
-			}
-		}
-	}
-
-	accept := false
-	if acceptParam, ok := req.Params["accept"].(bool); ok {
-		accept = acceptParam
-	}
 
 	if err := manager.SubmitPairing(token, secrets, accept); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "pairing response submitted"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "pairing response submitted"})
 }
 
-func handlePairingCancel(conn net.Conn, req Request, manager *Manager) {
+func handlePairingCancel(conn net.Conn, req models.Request, manager *Manager) {
-	token, ok := req.Params["token"].(string)
+	token, err := params.String(req.Params, "token")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'token' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -225,10 +202,10 @@ func handlePairingCancel(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "pairing cancelled"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "pairing cancelled"})
 }
 
-func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
+func handleSubscribe(conn net.Conn, req models.Request, manager *Manager) {
 	clientID := fmt.Sprintf("client-%p", conn)
 	stateChan := manager.Subscribe(clientID)
 	defer manager.Unsubscribe(clientID)

core/internal/server/brightness/handlers.go

@@ -2,12 +2,14 @@ package brightness
 
 import (
 	"encoding/json"
+	"fmt"
 	"net"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/params"
 )
 
-func HandleRequest(conn net.Conn, req Request, m *Manager) {
+func HandleRequest(conn net.Conn, req models.Request, m *Manager) {
 	switch req.Method {
 	case "brightness.getState":
 		handleGetState(conn, req, m)
@@ -22,131 +24,90 @@ func HandleRequest(conn net.Conn, req Request, m *Manager) {
 	case "brightness.subscribe":
 		handleSubscribe(conn, req, m)
 	default:
-		models.RespondError(conn, req.ID.(int), "unknown method: "+req.Method)
+		models.RespondError(conn, req.ID, "unknown method: "+req.Method)
 	}
 }
 
-func handleGetState(conn net.Conn, req Request, m *Manager) {
+func handleGetState(conn net.Conn, req models.Request, m *Manager) {
-	state := m.GetState()
+	models.Respond(conn, req.ID, m.GetState())
-	models.Respond(conn, req.ID.(int), state)
 }
 
-func handleSetBrightness(conn net.Conn, req Request, m *Manager) {
+func handleSetBrightness(conn net.Conn, req models.Request, m *Manager) {
-	var params SetBrightnessParams
+	device, err := params.String(req.Params, "device")
-
+	if err != nil {
-	device, ok := req.Params["device"].(string)
+		models.RespondError(conn, req.ID, err.Error())
-	if !ok {
-		models.RespondError(conn, req.ID.(int), "missing or invalid device parameter")
-		return
-	}
-	params.Device = device
-
-	percentFloat, ok := req.Params["percent"].(float64)
-	if !ok {
-		models.RespondError(conn, req.ID.(int), "missing or invalid percent parameter")
-		return
-	}
-	params.Percent = int(percentFloat)
-
-	if exponential, ok := req.Params["exponential"].(bool); ok {
-		params.Exponential = exponential
-	}
-
-	exponent := 1.2
-	if exponentFloat, ok := req.Params["exponent"].(float64); ok {
-		params.Exponent = exponentFloat
-		exponent = exponentFloat
-	}
-
-	if err := m.SetBrightnessWithExponent(params.Device, params.Percent, params.Exponential, exponent); err != nil {
-		models.RespondError(conn, req.ID.(int), err.Error())
 		return
 	}
 
-	state := m.GetState()
+	percent, err := params.Int(req.Params, "percent")
-	models.Respond(conn, req.ID.(int), state)
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	exponential := params.BoolOpt(req.Params, "exponential", false)
+	exponent := params.FloatOpt(req.Params, "exponent", 1.2)
+
+	if err := m.SetBrightnessWithExponent(device, percent, exponential, exponent); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, m.GetState())
 }
 
-func handleIncrement(conn net.Conn, req Request, m *Manager) {
+func handleIncrement(conn net.Conn, req models.Request, m *Manager) {
-	device, ok := req.Params["device"].(string)
+	device, err := params.String(req.Params, "device")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID.(int), "missing or invalid device parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	step := 10
+	step := params.IntOpt(req.Params, "step", 10)
-	if stepFloat, ok := req.Params["step"].(float64); ok {
+	exponential := params.BoolOpt(req.Params, "exponential", false)
-		step = int(stepFloat)
+	exponent := params.FloatOpt(req.Params, "exponent", 1.2)
-	}
-
-	exponential := false
-	if expBool, ok := req.Params["exponential"].(bool); ok {
-		exponential = expBool
-	}
-
-	exponent := 1.2
-	if exponentFloat, ok := req.Params["exponent"].(float64); ok {
-		exponent = exponentFloat
-	}
 
 	if err := m.IncrementBrightnessWithExponent(device, step, exponential, exponent); err != nil {
-		models.RespondError(conn, req.ID.(int), err.Error())
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	state := m.GetState()
+	models.Respond(conn, req.ID, m.GetState())
-	models.Respond(conn, req.ID.(int), state)
 }
 
-func handleDecrement(conn net.Conn, req Request, m *Manager) {
+func handleDecrement(conn net.Conn, req models.Request, m *Manager) {
-	device, ok := req.Params["device"].(string)
+	device, err := params.String(req.Params, "device")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID.(int), "missing or invalid device parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	step := 10
+	step := params.IntOpt(req.Params, "step", 10)
-	if stepFloat, ok := req.Params["step"].(float64); ok {
+	exponential := params.BoolOpt(req.Params, "exponential", false)
-		step = int(stepFloat)
+	exponent := params.FloatOpt(req.Params, "exponent", 1.2)
-	}
-
-	exponential := false
-	if expBool, ok := req.Params["exponential"].(bool); ok {
-		exponential = expBool
-	}
-
-	exponent := 1.2
-	if exponentFloat, ok := req.Params["exponent"].(float64); ok {
-		exponent = exponentFloat
-	}
 
 	if err := m.IncrementBrightnessWithExponent(device, -step, exponential, exponent); err != nil {
-		models.RespondError(conn, req.ID.(int), err.Error())
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	state := m.GetState()
+	models.Respond(conn, req.ID, m.GetState())
-	models.Respond(conn, req.ID.(int), state)
 }
 
-func handleRescan(conn net.Conn, req Request, m *Manager) {
+func handleRescan(conn net.Conn, req models.Request, m *Manager) {
 	m.Rescan()
-	state := m.GetState()
+	models.Respond(conn, req.ID, m.GetState())
-	models.Respond(conn, req.ID.(int), state)
 }
 
-func handleSubscribe(conn net.Conn, req Request, m *Manager) {
+func handleSubscribe(conn net.Conn, req models.Request, m *Manager) {
-	clientID := "brightness-subscriber"
+	clientID := fmt.Sprintf("brightness-%d", req.ID)
-	if idStr, ok := req.ID.(string); ok && idStr != "" {
-		clientID = idStr
-	}
 
 	ch := m.Subscribe(clientID)
 	defer m.Unsubscribe(clientID)
 
 	initialState := m.GetState()
 	if err := json.NewEncoder(conn).Encode(models.Response[State]{
-		ID:     req.ID.(int),
+		ID:     req.ID,
 		Result: &initialState,
 	}); err != nil {
 		return
@@ -154,7 +115,7 @@ func handleSubscribe(conn net.Conn, req Request, m *Manager) {
 
 	for state := range ch {
 		if err := json.NewEncoder(conn).Encode(models.Response[State]{
-			ID:     req.ID.(int),
+			ID:     req.ID,
 			Result: &state,
 		}); err != nil {
 			return

core/internal/server/brightness/types.go

@@ -33,12 +33,6 @@ type DeviceUpdate struct {
 	Device Device `json:"device"`
 }
 
-type Request struct {
-	ID     any            `json:"id"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params"`
-}
-
 type Manager struct {
 	logindBackend *LogindBackend
 	sysfsBackend  *SysfsBackend
@@ -112,13 +106,6 @@ type ddcCapability struct {
 	current int
 }
 
-type SetBrightnessParams struct {
-	Device      string  `json:"device"`
-	Percent     int     `json:"percent"`
-	Exponential bool    `json:"exponential,omitempty"`
-	Exponent    float64 `json:"exponent,omitempty"`
-}
-
 func (m *Manager) Subscribe(id string) chan State {
 	ch := make(chan State, 16)
 

core/internal/server/browser/handlers.go

@@ -6,13 +6,7 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
 )
 
-type Request struct {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
-	ID     int            `json:"id"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params"`
-}
-
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	switch req.Method {
 	case "browser.open":
 		url, ok := req.Params["url"].(string)

core/internal/server/cups/handlers.go

@@ -6,25 +6,21 @@ import (
 	"net"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/params"
 )
 
-type Request struct {
-	ID     int            `json:"id,omitempty"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params,omitempty"`
-}
-
-type SuccessResult struct {
-	Success bool   `json:"success"`
-	Message string `json:"message"`
-}
-
 type CUPSEvent struct {
 	Type string    `json:"type"`
 	Data CUPSState `json:"data"`
 }
 
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
+type TestPageResult struct {
+	Success bool   `json:"success"`
+	JobID   int    `json:"jobId"`
+	Message string `json:"message"`
+}
+
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 	switch req.Method {
 	case "cups.subscribe":
 		handleSubscribe(conn, req, manager)
@@ -79,20 +75,19 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleGetPrinters(conn net.Conn, req Request, manager *Manager) {
+func handleGetPrinters(conn net.Conn, req models.Request, manager *Manager) {
 	printers, err := manager.GetPrinters()
 	if err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-
 	models.Respond(conn, req.ID, printers)
 }
 
-func handleGetJobs(conn net.Conn, req Request, manager *Manager) {
+func handleGetJobs(conn net.Conn, req models.Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
+	printerName, err := params.String(req.Params, "printerName")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -101,14 +96,13 @@ func handleGetJobs(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-
 	models.Respond(conn, req.ID, jobs)
 }
 
-func handlePausePrinter(conn net.Conn, req Request, manager *Manager) {
+func handlePausePrinter(conn net.Conn, req models.Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
+	printerName, err := params.String(req.Params, "printerName")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -116,13 +110,13 @@ func handlePausePrinter(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "paused"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "paused"})
 }
 
-func handleResumePrinter(conn net.Conn, req Request, manager *Manager) {
+func handleResumePrinter(conn net.Conn, req models.Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
+	printerName, err := params.String(req.Params, "printerName")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -130,28 +124,27 @@ func handleResumePrinter(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "resumed"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "resumed"})
 }
 
-func handleCancelJob(conn net.Conn, req Request, manager *Manager) {
+func handleCancelJob(conn net.Conn, req models.Request, manager *Manager) {
-	jobIDFloat, ok := req.Params["jobID"].(float64)
+	jobID, err := params.Int(req.Params, "jobID")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'jobid' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	jobID := int(jobIDFloat)
 
 	if err := manager.CancelJob(jobID); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "job canceled"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "job canceled"})
 }
 
-func handlePurgeJobs(conn net.Conn, req Request, manager *Manager) {
+func handlePurgeJobs(conn net.Conn, req models.Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
+	printerName, err := params.String(req.Params, "printerName")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -159,10 +152,10 @@ func handlePurgeJobs(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "jobs canceled"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "jobs canceled"})
 }
 
-func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
+func handleSubscribe(conn net.Conn, req models.Request, manager *Manager) {
 	clientID := fmt.Sprintf("client-%p", conn)
 	stateChan := manager.Subscribe(clientID)
 	defer manager.Unsubscribe(clientID)
@@ -193,7 +186,7 @@ func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleGetDevices(conn net.Conn, req Request, manager *Manager) {
+func handleGetDevices(conn net.Conn, req models.Request, manager *Manager) {
 	devices, err := manager.GetDevices()
 	if err != nil {
 		models.RespondError(conn, req.ID, err.Error())
@@ -202,7 +195,7 @@ func handleGetDevices(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, devices)
 }
 
-func handleGetPPDs(conn net.Conn, req Request, manager *Manager) {
+func handleGetPPDs(conn net.Conn, req models.Request, manager *Manager) {
 	ppds, err := manager.GetPPDs()
 	if err != nil {
 		models.RespondError(conn, req.ID, err.Error())
@@ -211,7 +204,7 @@ func handleGetPPDs(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, ppds)
 }
 
-func handleGetClasses(conn net.Conn, req Request, manager *Manager) {
+func handleGetClasses(conn net.Conn, req models.Request, manager *Manager) {
 	classes, err := manager.GetClasses()
 	if err != nil {
 		models.RespondError(conn, req.ID, err.Error())
@@ -220,41 +213,41 @@ func handleGetClasses(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, classes)
 }
 
-func handleCreatePrinter(conn net.Conn, req Request, manager *Manager) {
+func handleCreatePrinter(conn net.Conn, req models.Request, manager *Manager) {
-	name, ok := req.Params["name"].(string)
+	name, err := params.StringNonEmpty(req.Params, "name")
-	if !ok || name == "" {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'name' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	deviceURI, ok := req.Params["deviceURI"].(string)
+	deviceURI, err := params.StringNonEmpty(req.Params, "deviceURI")
-	if !ok || deviceURI == "" {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'deviceURI' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	ppd, ok := req.Params["ppd"].(string)
+	ppd, err := params.StringNonEmpty(req.Params, "ppd")
-	if !ok || ppd == "" {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'ppd' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	shared, _ := req.Params["shared"].(bool)
+	shared := params.BoolOpt(req.Params, "shared", false)
-	errorPolicy, _ := req.Params["errorPolicy"].(string)
+	errorPolicy := params.StringOpt(req.Params, "errorPolicy", "")
-	information, _ := req.Params["information"].(string)
+	information := params.StringOpt(req.Params, "information", "")
-	location, _ := req.Params["location"].(string)
+	location := params.StringOpt(req.Params, "location", "")
 
 	if err := manager.CreatePrinter(name, deviceURI, ppd, shared, errorPolicy, information, location); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "printer created"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "printer created"})
 }
 
-func handleDeletePrinter(conn net.Conn, req Request, manager *Manager) {
+func handleDeletePrinter(conn net.Conn, req models.Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
+	printerName, err := params.StringNonEmpty(req.Params, "printerName")
-	if !ok || printerName == "" {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -262,13 +255,13 @@ func handleDeletePrinter(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "printer deleted"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "printer deleted"})
 }
 
-func handleAcceptJobs(conn net.Conn, req Request, manager *Manager) {
+func handleAcceptJobs(conn net.Conn, req models.Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
+	printerName, err := params.StringNonEmpty(req.Params, "printerName")
-	if !ok || printerName == "" {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -276,13 +269,13 @@ func handleAcceptJobs(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "accepting jobs"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "accepting jobs"})
 }
 
-func handleRejectJobs(conn net.Conn, req Request, manager *Manager) {
+func handleRejectJobs(conn net.Conn, req models.Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
+	printerName, err := params.StringNonEmpty(req.Params, "printerName")
-	if !ok || printerName == "" {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -290,19 +283,19 @@ func handleRejectJobs(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "rejecting jobs"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "rejecting jobs"})
 }
 
-func handleSetPrinterShared(conn net.Conn, req Request, manager *Manager) {
+func handleSetPrinterShared(conn net.Conn, req models.Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
+	printerName, err := params.StringNonEmpty(req.Params, "printerName")
-	if !ok || printerName == "" {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	shared, ok := req.Params["shared"].(bool)
+	shared, err := params.Bool(req.Params, "shared")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'shared' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -310,19 +303,19 @@ func handleSetPrinterShared(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "sharing updated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "sharing updated"})
 }
 
-func handleSetPrinterLocation(conn net.Conn, req Request, manager *Manager) {
+func handleSetPrinterLocation(conn net.Conn, req models.Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
+	printerName, err := params.StringNonEmpty(req.Params, "printerName")
-	if !ok || printerName == "" {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	location, ok := req.Params["location"].(string)
+	location, err := params.String(req.Params, "location")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'location' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -330,19 +323,19 @@ func handleSetPrinterLocation(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "location updated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "location updated"})
 }
 
-func handleSetPrinterInfo(conn net.Conn, req Request, manager *Manager) {
+func handleSetPrinterInfo(conn net.Conn, req models.Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
+	printerName, err := params.StringNonEmpty(req.Params, "printerName")
-	if !ok || printerName == "" {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	info, ok := req.Params["info"].(string)
+	info, err := params.String(req.Params, "info")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'info' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -350,39 +343,33 @@ func handleSetPrinterInfo(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "info updated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "info updated"})
 }
 
-func handleMoveJob(conn net.Conn, req Request, manager *Manager) {
+func handleMoveJob(conn net.Conn, req models.Request, manager *Manager) {
-	jobIDFloat, ok := req.Params["jobID"].(float64)
+	jobID, err := params.Int(req.Params, "jobID")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'jobID' parameter")
-		return
-	}
-
-	destPrinter, ok := req.Params["destPrinter"].(string)
-	if !ok || destPrinter == "" {
-		models.RespondError(conn, req.ID, "missing or invalid 'destPrinter' parameter")
-		return
-	}
-
-	if err := manager.MoveJob(int(jobIDFloat), destPrinter); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "job moved"})
+
+	destPrinter, err := params.StringNonEmpty(req.Params, "destPrinter")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	if err := manager.MoveJob(jobID, destPrinter); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "job moved"})
 }
 
-type TestPageResult struct {
+func handlePrintTestPage(conn net.Conn, req models.Request, manager *Manager) {
-	Success bool   `json:"success"`
+	printerName, err := params.StringNonEmpty(req.Params, "printerName")
-	JobID   int    `json:"jobId"`
+	if err != nil {
-	Message string `json:"message"`
+		models.RespondError(conn, req.ID, err.Error())
-}
-
-func handlePrintTestPage(conn net.Conn, req Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
-	if !ok || printerName == "" {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
 		return
 	}
 
@@ -394,16 +381,16 @@ func handlePrintTestPage(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, TestPageResult{Success: true, JobID: jobID, Message: "test page queued"})
 }
 
-func handleAddPrinterToClass(conn net.Conn, req Request, manager *Manager) {
+func handleAddPrinterToClass(conn net.Conn, req models.Request, manager *Manager) {
-	className, ok := req.Params["className"].(string)
+	className, err := params.StringNonEmpty(req.Params, "className")
-	if !ok || className == "" {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'className' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	printerName, ok := req.Params["printerName"].(string)
+	printerName, err := params.StringNonEmpty(req.Params, "printerName")
-	if !ok || printerName == "" {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -411,19 +398,19 @@ func handleAddPrinterToClass(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "printer added to class"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "printer added to class"})
 }
 
-func handleRemovePrinterFromClass(conn net.Conn, req Request, manager *Manager) {
+func handleRemovePrinterFromClass(conn net.Conn, req models.Request, manager *Manager) {
-	className, ok := req.Params["className"].(string)
+	className, err := params.StringNonEmpty(req.Params, "className")
-	if !ok || className == "" {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'className' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	printerName, ok := req.Params["printerName"].(string)
+	printerName, err := params.StringNonEmpty(req.Params, "printerName")
-	if !ok || printerName == "" {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -431,13 +418,13 @@ func handleRemovePrinterFromClass(conn net.Conn, req Request, manager *Manager)
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "printer removed from class"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "printer removed from class"})
 }
 
-func handleDeleteClass(conn net.Conn, req Request, manager *Manager) {
+func handleDeleteClass(conn net.Conn, req models.Request, manager *Manager) {
-	className, ok := req.Params["className"].(string)
+	className, err := params.StringNonEmpty(req.Params, "className")
-	if !ok || className == "" {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'className' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -445,38 +432,35 @@ func handleDeleteClass(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "class deleted"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "class deleted"})
 }
 
-func handleRestartJob(conn net.Conn, req Request, manager *Manager) {
+func handleRestartJob(conn net.Conn, req models.Request, manager *Manager) {
-	jobIDFloat, ok := req.Params["jobID"].(float64)
+	jobID, err := params.Int(req.Params, "jobID")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'jobID' parameter")
-		return
-	}
-
-	if err := manager.RestartJob(int(jobIDFloat)); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "job restarted"})
-}
 
-func handleHoldJob(conn net.Conn, req Request, manager *Manager) {
+	if err := manager.RestartJob(jobID); err != nil {
-	jobIDFloat, ok := req.Params["jobID"].(float64)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'jobID' parameter")
-		return
-	}
-
-	holdUntil, _ := req.Params["holdUntil"].(string)
-	if holdUntil == "" {
-		holdUntil = "indefinite"
-	}
-
-	if err := manager.HoldJob(int(jobIDFloat), holdUntil); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "job held"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "job restarted"})
+}
+
+func handleHoldJob(conn net.Conn, req models.Request, manager *Manager) {
+	jobID, err := params.Int(req.Params, "jobID")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	holdUntil := params.StringOpt(req.Params, "holdUntil", "indefinite")
+
+	if err := manager.HoldJob(jobID, holdUntil); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "job held"})
 }

core/internal/server/cups/handlers_test.go

@@ -43,7 +43,7 @@ func TestHandleGetPrinters(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.getPrinters",
 	}
@@ -68,7 +68,7 @@ func TestHandleGetPrinters_Error(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.getPrinters",
 	}
@@ -100,7 +100,7 @@ func TestHandleGetJobs(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.getJobs",
 		Params: map[string]any{
@@ -127,7 +127,7 @@ func TestHandleGetJobs_MissingParam(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.getJobs",
 		Params: map[string]any{},
@@ -152,7 +152,7 @@ func TestHandlePausePrinter(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.pausePrinter",
 		Params: map[string]any{
@@ -162,7 +162,7 @@ func TestHandlePausePrinter(t *testing.T) {
 
 	handlePausePrinter(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -179,7 +179,7 @@ func TestHandleResumePrinter(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.resumePrinter",
 		Params: map[string]any{
@@ -189,7 +189,7 @@ func TestHandleResumePrinter(t *testing.T) {
 
 	handleResumePrinter(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -206,7 +206,7 @@ func TestHandleCancelJob(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.cancelJob",
 		Params: map[string]any{
@@ -216,7 +216,7 @@ func TestHandleCancelJob(t *testing.T) {
 
 	handleCancelJob(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -233,7 +233,7 @@ func TestHandlePurgeJobs(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.purgeJobs",
 		Params: map[string]any{
@@ -243,7 +243,7 @@ func TestHandlePurgeJobs(t *testing.T) {
 
 	handlePurgeJobs(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -260,7 +260,7 @@ func TestHandleRequest_UnknownMethod(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.unknownMethod",
 	}
@@ -287,7 +287,7 @@ func TestHandleGetDevices(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{ID: 1, Method: "cups.getDevices"}
+	req := models.Request{ID: 1, Method: "cups.getDevices"}
 	handleGetDevices(conn, req, m)
 
 	var resp models.Response[[]Device]
@@ -309,7 +309,7 @@ func TestHandleGetPPDs(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{ID: 1, Method: "cups.getPPDs"}
+	req := models.Request{ID: 1, Method: "cups.getPPDs"}
 	handleGetPPDs(conn, req, m)
 
 	var resp models.Response[[]PPD]
@@ -332,7 +332,7 @@ func TestHandleGetClasses(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{ID: 1, Method: "cups.getClasses"}
+	req := models.Request{ID: 1, Method: "cups.getClasses"}
 	handleGetClasses(conn, req, m)
 
 	var resp models.Response[[]PrinterClass]
@@ -353,7 +353,7 @@ func TestHandleCreatePrinter(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.createPrinter",
 		Params: map[string]any{
@@ -364,7 +364,7 @@ func TestHandleCreatePrinter(t *testing.T) {
 	}
 	handleCreatePrinter(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -377,7 +377,7 @@ func TestHandleCreatePrinter_MissingParams(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{ID: 1, Method: "cups.createPrinter", Params: map[string]any{}}
+	req := models.Request{ID: 1, Method: "cups.createPrinter", Params: map[string]any{}}
 	handleCreatePrinter(conn, req, m)
 
 	var resp models.Response[any]
@@ -396,14 +396,14 @@ func TestHandleDeletePrinter(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.deletePrinter",
 		Params: map[string]any{"printerName": "printer1"},
 	}
 	handleDeletePrinter(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -419,14 +419,14 @@ func TestHandleAcceptJobs(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.acceptJobs",
 		Params: map[string]any{"printerName": "printer1"},
 	}
 	handleAcceptJobs(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -442,14 +442,14 @@ func TestHandleRejectJobs(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.rejectJobs",
 		Params: map[string]any{"printerName": "printer1"},
 	}
 	handleRejectJobs(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -465,14 +465,14 @@ func TestHandleSetPrinterShared(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.setPrinterShared",
 		Params: map[string]any{"printerName": "printer1", "shared": true},
 	}
 	handleSetPrinterShared(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -488,14 +488,14 @@ func TestHandleSetPrinterLocation(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.setPrinterLocation",
 		Params: map[string]any{"printerName": "printer1", "location": "Office"},
 	}
 	handleSetPrinterLocation(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -511,14 +511,14 @@ func TestHandleSetPrinterInfo(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.setPrinterInfo",
 		Params: map[string]any{"printerName": "printer1", "info": "Main Printer"},
 	}
 	handleSetPrinterInfo(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -534,14 +534,14 @@ func TestHandleMoveJob(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.moveJob",
 		Params: map[string]any{"jobID": float64(1), "destPrinter": "printer2"},
 	}
 	handleMoveJob(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -557,7 +557,7 @@ func TestHandlePrintTestPage(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.printTestPage",
 		Params: map[string]any{"printerName": "printer1"},
@@ -581,14 +581,14 @@ func TestHandleAddPrinterToClass(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.addPrinterToClass",
 		Params: map[string]any{"className": "office", "printerName": "printer1"},
 	}
 	handleAddPrinterToClass(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -604,14 +604,14 @@ func TestHandleRemovePrinterFromClass(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.removePrinterFromClass",
 		Params: map[string]any{"className": "office", "printerName": "printer1"},
 	}
 	handleRemovePrinterFromClass(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -627,14 +627,14 @@ func TestHandleDeleteClass(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.deleteClass",
 		Params: map[string]any{"className": "office"},
 	}
 	handleDeleteClass(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -650,14 +650,14 @@ func TestHandleRestartJob(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.restartJob",
 		Params: map[string]any{"jobID": float64(1)},
 	}
 	handleRestartJob(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -673,14 +673,14 @@ func TestHandleHoldJob(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.holdJob",
 		Params: map[string]any{"jobID": float64(1)},
 	}
 	handleHoldJob(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -696,14 +696,14 @@ func TestHandleHoldJob_WithHoldUntil(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.holdJob",
 		Params: map[string]any{"jobID": float64(1), "holdUntil": "no-hold"},
 	}
 	handleHoldJob(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)

core/internal/server/dwl/handlers.go

@@ -8,18 +8,12 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
 )
 
-type Request struct {
-	ID     int            `json:"id,omitempty"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params,omitempty"`
-}
-
 type SuccessResult struct {
 	Success bool   `json:"success"`
 	Message string `json:"message"`
 }
 
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 	if manager == nil {
 		models.RespondError(conn, req.ID, "dwl manager not initialized")
 		return
@@ -41,12 +35,12 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleGetState(conn net.Conn, req Request, manager *Manager) {
+func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
 	state := manager.GetState()
 	models.Respond(conn, req.ID, state)
 }
 
-func handleSetTags(conn net.Conn, req Request, manager *Manager) {
+func handleSetTags(conn net.Conn, req models.Request, manager *Manager) {
 	output, ok := req.Params["output"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'output' parameter")
@@ -73,7 +67,7 @@ func handleSetTags(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "tags set"})
 }
 
-func handleSetClientTags(conn net.Conn, req Request, manager *Manager) {
+func handleSetClientTags(conn net.Conn, req models.Request, manager *Manager) {
 	output, ok := req.Params["output"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'output' parameter")
@@ -100,7 +94,7 @@ func handleSetClientTags(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "client tags set"})
 }
 
-func handleSetLayout(conn net.Conn, req Request, manager *Manager) {
+func handleSetLayout(conn net.Conn, req models.Request, manager *Manager) {
 	output, ok := req.Params["output"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'output' parameter")
@@ -121,7 +115,7 @@ func handleSetLayout(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "layout set"})
 }
 
-func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
+func handleSubscribe(conn net.Conn, req models.Request, manager *Manager) {
 	clientID := fmt.Sprintf("client-%p", conn)
 	stateChan := manager.Subscribe(clientID)
 	defer manager.Unsubscribe(clientID)

core/internal/server/evdev/handlers.go

@@ -6,22 +6,15 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
 )
 
-type Request struct {
+func HandleRequest(conn net.Conn, req models.Request, m *Manager) {
-	ID     any            `json:"id"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params"`
-}
-
-func HandleRequest(conn net.Conn, req Request, m *Manager) {
 	switch req.Method {
 	case "evdev.getState":
 		handleGetState(conn, req, m)
 	default:
-		models.RespondError(conn, req.ID.(int), "unknown method: "+req.Method)
+		models.RespondError(conn, req.ID, "unknown method: "+req.Method)
 	}
 }
 
-func handleGetState(conn net.Conn, req Request, m *Manager) {
+func handleGetState(conn net.Conn, req models.Request, m *Manager) {
-	state := m.GetState()
+	models.Respond(conn, req.ID, m.GetState())
-	models.Respond(conn, req.ID.(int), state)
 }

core/internal/server/evdev/handlers_test.go

@@ -53,7 +53,7 @@ func TestHandleRequest(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "evdev.getState",
 			Params: map[string]any{},
@@ -82,7 +82,7 @@ func TestHandleRequest(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     456,
 			Method: "evdev.unknownMethod",
 			Params: map[string]any{},
@@ -111,7 +111,7 @@ func TestHandleGetState(t *testing.T) {
 	}
 
 	conn := newMockNetConn()
-	req := Request{
+	req := models.Request{
 		ID:     789,
 		Method: "evdev.getState",
 		Params: map[string]any{},

core/internal/server/extworkspace/handlers.go

@@ -8,18 +8,12 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
 )
 
-type Request struct {
-	ID     int            `json:"id,omitempty"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params,omitempty"`
-}
-
 type SuccessResult struct {
 	Success bool   `json:"success"`
 	Message string `json:"message"`
 }
 
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 	if manager == nil {
 		models.RespondError(conn, req.ID, "extworkspace manager not initialized")
 		return
@@ -43,12 +37,12 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleGetState(conn net.Conn, req Request, manager *Manager) {
+func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
 	state := manager.GetState()
 	models.Respond(conn, req.ID, state)
 }
 
-func handleActivateWorkspace(conn net.Conn, req Request, manager *Manager) {
+func handleActivateWorkspace(conn net.Conn, req models.Request, manager *Manager) {
 	groupID, ok := req.Params["groupID"].(string)
 	if !ok {
 		groupID = ""
@@ -68,7 +62,7 @@ func handleActivateWorkspace(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "workspace activated"})
 }
 
-func handleDeactivateWorkspace(conn net.Conn, req Request, manager *Manager) {
+func handleDeactivateWorkspace(conn net.Conn, req models.Request, manager *Manager) {
 	groupID, ok := req.Params["groupID"].(string)
 	if !ok {
 		groupID = ""
@@ -88,7 +82,7 @@ func handleDeactivateWorkspace(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "workspace deactivated"})
 }
 
-func handleRemoveWorkspace(conn net.Conn, req Request, manager *Manager) {
+func handleRemoveWorkspace(conn net.Conn, req models.Request, manager *Manager) {
 	groupID, ok := req.Params["groupID"].(string)
 	if !ok {
 		groupID = ""
@@ -108,7 +102,7 @@ func handleRemoveWorkspace(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "workspace removed"})
 }
 
-func handleCreateWorkspace(conn net.Conn, req Request, manager *Manager) {
+func handleCreateWorkspace(conn net.Conn, req models.Request, manager *Manager) {
 	groupID, ok := req.Params["groupID"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'groupID' parameter")
@@ -129,7 +123,7 @@ func handleCreateWorkspace(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "workspace create requested"})
 }
 
-func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
+func handleSubscribe(conn net.Conn, req models.Request, manager *Manager) {
 	clientID := fmt.Sprintf("client-%p", conn)
 	stateChan := manager.Subscribe(clientID)
 	defer manager.Unsubscribe(clientID)

core/internal/server/freedesktop/handlers.go

@@ -5,21 +5,10 @@ import (
 	"net"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/params"
 )
 
-type Request struct {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
-	ID     int            `json:"id,omitempty"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params,omitempty"`
-}
-
-type SuccessResult struct {
-	Success bool   `json:"success"`
-	Message string `json:"message"`
-	Value   string `json:"value,omitempty"`
-}
-
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	switch req.Method {
 	case "freedesktop.getState":
 		handleGetState(conn, req, manager)
@@ -44,15 +33,14 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleGetState(conn net.Conn, req Request, manager *Manager) {
+func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
-	state := manager.GetState()
+	models.Respond(conn, req.ID, manager.GetState())
-	models.Respond(conn, req.ID, state)
 }
 
-func handleSetIconFile(conn net.Conn, req Request, manager *Manager) {
+func handleSetIconFile(conn net.Conn, req models.Request, manager *Manager) {
-	iconPath, ok := req.Params["path"].(string)
+	iconPath, err := params.String(req.Params, "path")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'path' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -61,13 +49,13 @@ func handleSetIconFile(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "icon file set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "icon file set"})
 }
 
-func handleSetRealName(conn net.Conn, req Request, manager *Manager) {
+func handleSetRealName(conn net.Conn, req models.Request, manager *Manager) {
-	name, ok := req.Params["name"].(string)
+	name, err := params.String(req.Params, "name")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'name' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -76,13 +64,13 @@ func handleSetRealName(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "real name set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "real name set"})
 }
 
-func handleSetEmail(conn net.Conn, req Request, manager *Manager) {
+func handleSetEmail(conn net.Conn, req models.Request, manager *Manager) {
-	email, ok := req.Params["email"].(string)
+	email, err := params.String(req.Params, "email")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'email' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -91,13 +79,13 @@ func handleSetEmail(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "email set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "email set"})
 }
 
-func handleSetLanguage(conn net.Conn, req Request, manager *Manager) {
+func handleSetLanguage(conn net.Conn, req models.Request, manager *Manager) {
-	language, ok := req.Params["language"].(string)
+	language, err := params.String(req.Params, "language")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'language' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -106,13 +94,13 @@ func handleSetLanguage(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "language set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "language set"})
 }
 
-func handleSetLocation(conn net.Conn, req Request, manager *Manager) {
+func handleSetLocation(conn net.Conn, req models.Request, manager *Manager) {
-	location, ok := req.Params["location"].(string)
+	location, err := params.String(req.Params, "location")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'location' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -121,13 +109,13 @@ func handleSetLocation(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "location set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "location set"})
 }
 
-func handleGetUserIconFile(conn net.Conn, req Request, manager *Manager) {
+func handleGetUserIconFile(conn net.Conn, req models.Request, manager *Manager) {
-	username, ok := req.Params["username"].(string)
+	username, err := params.String(req.Params, "username")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'username' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -137,10 +125,10 @@ func handleGetUserIconFile(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Value: iconFile})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Value: iconFile})
 }
 
-func handleGetColorScheme(conn net.Conn, req Request, manager *Manager) {
+func handleGetColorScheme(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.updateSettingsState(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
@@ -150,10 +138,10 @@ func handleGetColorScheme(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, map[string]uint32{"colorScheme": state.Settings.ColorScheme})
 }
 
-func handleSetIconTheme(conn net.Conn, req Request, manager *Manager) {
+func handleSetIconTheme(conn net.Conn, req models.Request, manager *Manager) {
-	iconTheme, ok := req.Params["iconTheme"].(string)
+	iconTheme, err := params.String(req.Params, "iconTheme")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'iconTheme' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -162,5 +150,5 @@ func handleSetIconTheme(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "icon theme set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "icon theme set"})
 }

core/internal/server/freedesktop/handlers_test.go

@@ -74,10 +74,10 @@ func TestRespondError_Freedesktop(t *testing.T) {
 
 func TestRespond_Freedesktop(t *testing.T) {
 	conn := newMockNetConn()
-	result := SuccessResult{Success: true, Message: "test"}
+	result := models.SuccessResult{Success: true, Message: "test"}
 	models.Respond(conn, 123, result)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 	require.NoError(t, err)
 
@@ -106,7 +106,7 @@ func TestHandleGetState(t *testing.T) {
 	}
 
 	conn := newMockNetConn()
-	req := Request{ID: 123, Method: "freedesktop.getState"}
+	req := models.Request{ID: 123, Method: "freedesktop.getState"}
 
 	handleGetState(conn, req, manager)
 
@@ -131,7 +131,7 @@ func TestHandleSetIconFile(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.setIconFile",
 			Params: map[string]any{},
@@ -164,7 +164,7 @@ func TestHandleSetIconFile(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.setIconFile",
 			Params: map[string]any{
@@ -174,7 +174,7 @@ func TestHandleSetIconFile(t *testing.T) {
 
 		handleSetIconFile(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -196,7 +196,7 @@ func TestHandleSetIconFile(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.setIconFile",
 			Params: map[string]any{
@@ -206,7 +206,7 @@ func TestHandleSetIconFile(t *testing.T) {
 
 		handleSetIconFile(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -223,7 +223,7 @@ func TestHandleSetRealName(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.setRealName",
 			Params: map[string]any{},
@@ -256,7 +256,7 @@ func TestHandleSetRealName(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.setRealName",
 			Params: map[string]any{
@@ -266,7 +266,7 @@ func TestHandleSetRealName(t *testing.T) {
 
 		handleSetRealName(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -286,7 +286,7 @@ func TestHandleSetEmail(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.setEmail",
 			Params: map[string]any{},
@@ -319,7 +319,7 @@ func TestHandleSetEmail(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.setEmail",
 			Params: map[string]any{
@@ -329,7 +329,7 @@ func TestHandleSetEmail(t *testing.T) {
 
 		handleSetEmail(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -349,7 +349,7 @@ func TestHandleSetLanguage(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.setLanguage",
 			Params: map[string]any{},
@@ -374,7 +374,7 @@ func TestHandleSetLocation(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.setLocation",
 			Params: map[string]any{},
@@ -399,7 +399,7 @@ func TestHandleGetUserIconFile(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.getUserIconFile",
 			Params: map[string]any{},
@@ -426,7 +426,7 @@ func TestHandleGetUserIconFile(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.getUserIconFile",
 			Params: map[string]any{
@@ -436,7 +436,7 @@ func TestHandleGetUserIconFile(t *testing.T) {
 
 		handleGetUserIconFile(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -457,7 +457,7 @@ func TestHandleGetColorScheme(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "freedesktop.settings.getColorScheme"}
+		req := models.Request{ID: 123, Method: "freedesktop.settings.getColorScheme"}
 
 		handleGetColorScheme(conn, req, manager)
 
@@ -488,7 +488,7 @@ func TestHandleGetColorScheme(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "freedesktop.settings.getColorScheme"}
+		req := models.Request{ID: 123, Method: "freedesktop.settings.getColorScheme"}
 
 		handleGetColorScheme(conn, req, manager)
 
@@ -516,7 +516,7 @@ func TestHandleRequest(t *testing.T) {
 
 	t.Run("unknown method", func(t *testing.T) {
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.unknown",
 		}
@@ -533,7 +533,7 @@ func TestHandleRequest(t *testing.T) {
 
 	t.Run("valid method - getState", func(t *testing.T) {
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.getState",
 		}
@@ -561,7 +561,7 @@ func TestHandleRequest(t *testing.T) {
 
 		for _, method := range tests {
 			conn := newMockNetConn()
-			req := Request{
+			req := models.Request{
 				ID:     123,
 				Method: method,
 				Params: map[string]any{},

core/internal/server/loginctl/handlers.go

@@ -6,20 +6,10 @@ import (
 	"net"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/params"
 )
 
-type Request struct {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
-	ID     int            `json:"id,omitempty"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params,omitempty"`
-}
-
-type SuccessResult struct {
-	Success bool   `json:"success"`
-	Message string `json:"message"`
-}
-
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	switch req.Method {
 	case "loginctl.getState":
 		handleGetState(conn, req, manager)
@@ -46,39 +36,38 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleGetState(conn net.Conn, req Request, manager *Manager) {
+func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
-	state := manager.GetState()
+	models.Respond(conn, req.ID, manager.GetState())
-	models.Respond(conn, req.ID, state)
 }
 
-func handleLock(conn net.Conn, req Request, manager *Manager) {
+func handleLock(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.Lock(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "locked"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "locked"})
 }
 
-func handleUnlock(conn net.Conn, req Request, manager *Manager) {
+func handleUnlock(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.Unlock(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "unlocked"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "unlocked"})
 }
 
-func handleActivate(conn net.Conn, req Request, manager *Manager) {
+func handleActivate(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.Activate(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "activated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "activated"})
 }
 
-func handleSetIdleHint(conn net.Conn, req Request, manager *Manager) {
+func handleSetIdleHint(conn net.Conn, req models.Request, manager *Manager) {
-	idle, ok := req.Params["idle"].(bool)
+	idle, err := params.Bool(req.Params, "idle")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'idle' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -86,32 +75,32 @@ func handleSetIdleHint(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "idle hint set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "idle hint set"})
 }
 
-func handleSetLockBeforeSuspend(conn net.Conn, req Request, manager *Manager) {
+func handleSetLockBeforeSuspend(conn net.Conn, req models.Request, manager *Manager) {
-	enabled, ok := req.Params["enabled"].(bool)
+	enabled, err := params.Bool(req.Params, "enabled")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'enabled' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
 	manager.SetLockBeforeSuspend(enabled)
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "lock before suspend set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "lock before suspend set"})
 }
 
-func handleSetSleepInhibitorEnabled(conn net.Conn, req Request, manager *Manager) {
+func handleSetSleepInhibitorEnabled(conn net.Conn, req models.Request, manager *Manager) {
-	enabled, ok := req.Params["enabled"].(bool)
+	enabled, err := params.Bool(req.Params, "enabled")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'enabled' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
 	manager.SetSleepInhibitorEnabled(enabled)
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "sleep inhibitor setting updated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "sleep inhibitor setting updated"})
 }
 
-func handleLockerReady(conn net.Conn, req Request, manager *Manager) {
+func handleLockerReady(conn net.Conn, req models.Request, manager *Manager) {
 	manager.lockTimerMu.Lock()
 	if manager.lockTimer != nil {
 		manager.lockTimer.Stop()
@@ -125,18 +114,18 @@ func handleLockerReady(conn net.Conn, req Request, manager *Manager) {
 	if manager.inSleepCycle.Load() {
 		manager.signalLockerReady()
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "ok"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "ok"})
 }
 
-func handleTerminate(conn net.Conn, req Request, manager *Manager) {
+func handleTerminate(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.Terminate(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "terminated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "terminated"})
 }
 
-func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
+func handleSubscribe(conn net.Conn, req models.Request, manager *Manager) {
 	clientID := fmt.Sprintf("client-%p", conn)
 	stateChan := manager.Subscribe(clientID)
 	defer manager.Unsubscribe(clientID)

core/internal/server/loginctl/handlers_test.go

@@ -58,10 +58,10 @@ func TestRespondError_Loginctl(t *testing.T) {
 
 func TestRespond_Loginctl(t *testing.T) {
 	conn := newMockNetConn()
-	result := SuccessResult{Success: true, Message: "test"}
+	result := models.SuccessResult{Success: true, Message: "test"}
 	models.Respond(conn, 123, result)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 	require.NoError(t, err)
 
@@ -86,7 +86,7 @@ func TestHandleGetState(t *testing.T) {
 	}
 
 	conn := newMockNetConn()
-	req := Request{ID: 123, Method: "loginctl.getState"}
+	req := models.Request{ID: 123, Method: "loginctl.getState"}
 
 	handleGetState(conn, req, manager)
 
@@ -115,10 +115,10 @@ func TestHandleLock(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "loginctl.lock"}
+		req := models.Request{ID: 123, Method: "loginctl.lock"}
 		handleLock(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -141,10 +141,10 @@ func TestHandleLock(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "loginctl.lock"}
+		req := models.Request{ID: 123, Method: "loginctl.lock"}
 		handleLock(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -166,10 +166,10 @@ func TestHandleUnlock(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "loginctl.unlock"}
+		req := models.Request{ID: 123, Method: "loginctl.unlock"}
 		handleUnlock(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -192,10 +192,10 @@ func TestHandleUnlock(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "loginctl.unlock"}
+		req := models.Request{ID: 123, Method: "loginctl.unlock"}
 		handleUnlock(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -217,10 +217,10 @@ func TestHandleActivate(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "loginctl.activate"}
+		req := models.Request{ID: 123, Method: "loginctl.activate"}
 		handleActivate(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -243,10 +243,10 @@ func TestHandleActivate(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "loginctl.activate"}
+		req := models.Request{ID: 123, Method: "loginctl.activate"}
 		handleActivate(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -263,7 +263,7 @@ func TestHandleSetIdleHint(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "loginctl.setIdleHint",
 			Params: map[string]any{},
@@ -291,7 +291,7 @@ func TestHandleSetIdleHint(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "loginctl.setIdleHint",
 			Params: map[string]any{
@@ -301,7 +301,7 @@ func TestHandleSetIdleHint(t *testing.T) {
 
 		handleSetIdleHint(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -324,7 +324,7 @@ func TestHandleSetIdleHint(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "loginctl.setIdleHint",
 			Params: map[string]any{
@@ -334,7 +334,7 @@ func TestHandleSetIdleHint(t *testing.T) {
 
 		handleSetIdleHint(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -356,10 +356,10 @@ func TestHandleTerminate(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "loginctl.terminate"}
+		req := models.Request{ID: 123, Method: "loginctl.terminate"}
 		handleTerminate(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -382,10 +382,10 @@ func TestHandleTerminate(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "loginctl.terminate"}
+		req := models.Request{ID: 123, Method: "loginctl.terminate"}
 		handleTerminate(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -405,7 +405,7 @@ func TestHandleRequest(t *testing.T) {
 
 	t.Run("unknown method", func(t *testing.T) {
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "loginctl.unknown",
 		}
@@ -422,7 +422,7 @@ func TestHandleRequest(t *testing.T) {
 
 	t.Run("valid method - getState", func(t *testing.T) {
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "loginctl.getState",
 		}
@@ -445,7 +445,7 @@ func TestHandleRequest(t *testing.T) {
 		manager.sessionObj = mockSessionObj
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "loginctl.lock",
 		}
@@ -470,7 +470,7 @@ func TestHandleSubscribe(t *testing.T) {
 	}
 
 	conn := newMockNetConn()
-	req := Request{ID: 123, Method: "loginctl.subscribe"}
+	req := models.Request{ID: 123, Method: "loginctl.subscribe"}
 
 	done := make(chan bool)
 	go func() {

core/internal/server/models/types.go

@@ -29,3 +29,9 @@ func Respond[T any](conn net.Conn, id int, result T) {
 	resp := Response[T]{ID: id, Result: &result}
 	json.NewEncoder(conn).Encode(resp)
 }
+
+type SuccessResult struct {
+	Success bool   `json:"success"`
+	Message string `json:"message,omitempty"`
+	Value   string `json:"value,omitempty"`
+}

core/internal/server/network/handlers.go

@@ -7,20 +7,10 @@ import (
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/params"
 )
 
-type Request struct {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
-	ID     int            `json:"id,omitempty"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params,omitempty"`
-}
-
-type SuccessResult struct {
-	Success bool   `json:"success"`
-	Message string `json:"message"`
-}
-
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	switch req.Method {
 	case "network.getState":
 		handleGetState(conn, req, manager)
@@ -89,32 +79,22 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleCredentialsSubmit(conn net.Conn, req Request, manager *Manager) {
+func handleCredentialsSubmit(conn net.Conn, req models.Request, manager *Manager) {
-	token, ok := req.Params["token"].(string)
+	token, err := params.String(req.Params, "token")
-	if !ok {
+	if err != nil {
 		log.Warnf("handleCredentialsSubmit: missing or invalid token parameter")
-		models.RespondError(conn, req.ID, "missing or invalid 'token' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	secretsRaw, ok := req.Params["secrets"].(map[string]any)
+	secrets, err := params.StringMap(req.Params, "secrets")
-	if !ok {
+	if err != nil {
 		log.Warnf("handleCredentialsSubmit: missing or invalid secrets parameter")
-		models.RespondError(conn, req.ID, "missing or invalid 'secrets' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	secrets := make(map[string]string)
+	save := params.BoolOpt(req.Params, "save", true)
-	for k, v := range secretsRaw {
-		if str, ok := v.(string); ok {
-			secrets[k] = str
-		}
-	}
-
-	save := true
-	if saveParam, ok := req.Params["save"].(bool); ok {
-		save = saveParam
-	}
 
 	if err := manager.SubmitCredentials(token, secrets, save); err != nil {
 		log.Warnf("handleCredentialsSubmit: failed to submit credentials: %v", err)
@@ -123,13 +103,13 @@ func handleCredentialsSubmit(conn net.Conn, req Request, manager *Manager) {
 	}
 
 	log.Infof("handleCredentialsSubmit: credentials submitted successfully")
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "credentials submitted"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "credentials submitted"})
 }
 
-func handleCredentialsCancel(conn net.Conn, req Request, manager *Manager) {
+func handleCredentialsCancel(conn net.Conn, req models.Request, manager *Manager) {
-	token, ok := req.Params["token"].(string)
+	token, err := params.String(req.Params, "token")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'token' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -138,16 +118,15 @@ func handleCredentialsCancel(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "credentials cancelled"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "credentials cancelled"})
 }
 
-func handleGetState(conn net.Conn, req Request, manager *Manager) {
+func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
-	state := manager.GetState()
+	models.Respond(conn, req.ID, manager.GetState())
-	models.Respond(conn, req.ID, state)
 }
 
-func handleScanWiFi(conn net.Conn, req Request, manager *Manager) {
+func handleScanWiFi(conn net.Conn, req models.Request, manager *Manager) {
-	device, _ := req.Params["device"].(string)
+	device := params.StringOpt(req.Params, "device", "")
 	var err error
 	if device != "" {
 		err = manager.ScanWiFiDevice(device)
@@ -158,33 +137,25 @@ func handleScanWiFi(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "scanning"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "scanning"})
 }
 
-func handleGetWiFiNetworks(conn net.Conn, req Request, manager *Manager) {
+func handleGetWiFiNetworks(conn net.Conn, req models.Request, manager *Manager) {
-	networks := manager.GetWiFiNetworks()
+	models.Respond(conn, req.ID, manager.GetWiFiNetworks())
-	models.Respond(conn, req.ID, networks)
 }
 
-func handleConnectWiFi(conn net.Conn, req Request, manager *Manager) {
+func handleConnectWiFi(conn net.Conn, req models.Request, manager *Manager) {
-	ssid, ok := req.Params["ssid"].(string)
+	ssid, err := params.String(req.Params, "ssid")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'ssid' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
 	var connReq ConnectionRequest
 	connReq.SSID = ssid
-
+	connReq.Password = params.StringOpt(req.Params, "password", "")
-	if password, ok := req.Params["password"].(string); ok {
+	connReq.Username = params.StringOpt(req.Params, "username", "")
-		connReq.Password = password
+	connReq.Device = params.StringOpt(req.Params, "device", "")
-	}
-	if username, ok := req.Params["username"].(string); ok {
-		connReq.Username = username
-	}
-	if device, ok := req.Params["device"].(string); ok {
-		connReq.Device = device
-	}
 
 	if interactive, ok := req.Params["interactive"].(bool); ok {
 		connReq.Interactive = interactive
@@ -206,27 +177,14 @@ func handleConnectWiFi(conn net.Conn, req Request, manager *Manager) {
 		}
 	}
 
-	if anonymousIdentity, ok := req.Params["anonymousIdentity"].(string); ok {
+	connReq.AnonymousIdentity = params.StringOpt(req.Params, "anonymousIdentity", "")
-		connReq.AnonymousIdentity = anonymousIdentity
+	connReq.DomainSuffixMatch = params.StringOpt(req.Params, "domainSuffixMatch", "")
-	}
+	connReq.EAPMethod = params.StringOpt(req.Params, "eapMethod", "")
-	if domainSuffixMatch, ok := req.Params["domainSuffixMatch"].(string); ok {
+	connReq.Phase2Auth = params.StringOpt(req.Params, "phase2Auth", "")
-		connReq.DomainSuffixMatch = domainSuffixMatch
+	connReq.CACertPath = params.StringOpt(req.Params, "caCertPath", "")
-	}
+	connReq.ClientCertPath = params.StringOpt(req.Params, "clientCertPath", "")
-	if eapMethod, ok := req.Params["eapMethod"].(string); ok {
+	connReq.PrivateKeyPath = params.StringOpt(req.Params, "privateKeyPath", "")
-		connReq.EAPMethod = eapMethod
+
-	}
-	if phase2Auth, ok := req.Params["phase2Auth"].(string); ok {
-		connReq.Phase2Auth = phase2Auth
-	}
-	if caCertPath, ok := req.Params["caCertPath"].(string); ok {
-		connReq.CACertPath = caCertPath
-	}
-	if clientCertPath, ok := req.Params["clientCertPath"].(string); ok {
-		connReq.ClientCertPath = clientCertPath
-	}
-	if privateKeyPath, ok := req.Params["privateKeyPath"].(string); ok {
-		connReq.PrivateKeyPath = privateKeyPath
-	}
 	if useSystemCACerts, ok := req.Params["useSystemCACerts"].(bool); ok {
 		connReq.UseSystemCACerts = &useSystemCACerts
 	}
@@ -236,11 +194,11 @@ func handleConnectWiFi(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "connecting"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "connecting"})
 }
 
-func handleDisconnectWiFi(conn net.Conn, req Request, manager *Manager) {
+func handleDisconnectWiFi(conn net.Conn, req models.Request, manager *Manager) {
-	device, _ := req.Params["device"].(string)
+	device := params.StringOpt(req.Params, "device", "")
 	var err error
 	if device != "" {
 		err = manager.DisconnectWiFiDevice(device)
@@ -251,13 +209,13 @@ func handleDisconnectWiFi(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "disconnected"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "disconnected"})
 }
 
-func handleForgetWiFi(conn net.Conn, req Request, manager *Manager) {
+func handleForgetWiFi(conn net.Conn, req models.Request, manager *Manager) {
-	ssid, ok := req.Params["ssid"].(string)
+	ssid, err := params.String(req.Params, "ssid")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'ssid' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -266,10 +224,10 @@ func handleForgetWiFi(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "forgotten"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "forgotten"})
 }
 
-func handleToggleWiFi(conn net.Conn, req Request, manager *Manager) {
+func handleToggleWiFi(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.ToggleWiFi(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
@@ -279,7 +237,7 @@ func handleToggleWiFi(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, map[string]bool{"enabled": state.WiFiEnabled})
 }
 
-func handleEnableWiFi(conn net.Conn, req Request, manager *Manager) {
+func handleEnableWiFi(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.EnableWiFi(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
@@ -287,7 +245,7 @@ func handleEnableWiFi(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, map[string]bool{"enabled": true})
 }
 
-func handleDisableWiFi(conn net.Conn, req Request, manager *Manager) {
+func handleDisableWiFi(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.DisableWiFi(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
@@ -295,29 +253,29 @@ func handleDisableWiFi(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, map[string]bool{"enabled": false})
 }
 
-func handleConnectEthernetSpecificConfig(conn net.Conn, req Request, manager *Manager) {
+func handleConnectEthernetSpecificConfig(conn net.Conn, req models.Request, manager *Manager) {
-	uuid, ok := req.Params["uuid"].(string)
+	uuid, err := params.String(req.Params, "uuid")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'uuid' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 	if err := manager.activateConnection(uuid); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "connecting"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "connecting"})
 }
 
-func handleConnectEthernet(conn net.Conn, req Request, manager *Manager) {
+func handleConnectEthernet(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.ConnectEthernet(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "connecting"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "connecting"})
 }
 
-func handleDisconnectEthernet(conn net.Conn, req Request, manager *Manager) {
+func handleDisconnectEthernet(conn net.Conn, req models.Request, manager *Manager) {
-	device, _ := req.Params["device"].(string)
+	device := params.StringOpt(req.Params, "device", "")
 	var err error
 	if device != "" {
 		err = manager.DisconnectEthernetDevice(device)
@@ -328,13 +286,13 @@ func handleDisconnectEthernet(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "disconnected"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "disconnected"})
 }
 
-func handleSetPreference(conn net.Conn, req Request, manager *Manager) {
+func handleSetPreference(conn net.Conn, req models.Request, manager *Manager) {
-	preference, ok := req.Params["preference"].(string)
+	preference, err := params.String(req.Params, "preference")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'preference' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -346,10 +304,10 @@ func handleSetPreference(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, map[string]string{"preference": preference})
 }
 
-func handleGetNetworkInfo(conn net.Conn, req Request, manager *Manager) {
+func handleGetNetworkInfo(conn net.Conn, req models.Request, manager *Manager) {
-	ssid, ok := req.Params["ssid"].(string)
+	ssid, err := params.String(req.Params, "ssid")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'ssid' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -362,10 +320,10 @@ func handleGetNetworkInfo(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, network)
 }
 
-func handleGetWiredNetworkInfo(conn net.Conn, req Request, manager *Manager) {
+func handleGetWiredNetworkInfo(conn net.Conn, req models.Request, manager *Manager) {
-	uuid, ok := req.Params["uuid"].(string)
+	uuid, err := params.String(req.Params, "uuid")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'uuid' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -378,7 +336,7 @@ func handleGetWiredNetworkInfo(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, network)
 }
 
-func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
+func handleSubscribe(conn net.Conn, req models.Request, manager *Manager) {
 	clientID := fmt.Sprintf("client-%p", conn)
 	stateChan := manager.Subscribe(clientID)
 	defer manager.Unsubscribe(clientID)
@@ -408,7 +366,7 @@ func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleListVPNProfiles(conn net.Conn, req Request, manager *Manager) {
+func handleListVPNProfiles(conn net.Conn, req models.Request, manager *Manager) {
 	profiles, err := manager.ListVPNProfiles()
 	if err != nil {
 		log.Warnf("handleListVPNProfiles: failed to list profiles: %v", err)
@@ -419,7 +377,7 @@ func handleListVPNProfiles(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, profiles)
 }
 
-func handleListActiveVPN(conn net.Conn, req Request, manager *Manager) {
+func handleListActiveVPN(conn net.Conn, req models.Request, manager *Manager) {
 	active, err := manager.ListActiveVPN()
 	if err != nil {
 		log.Warnf("handleListActiveVPN: failed to list active VPNs: %v", err)
@@ -430,27 +388,15 @@ func handleListActiveVPN(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, active)
 }
 
-func handleConnectVPN(conn net.Conn, req Request, manager *Manager) {
+func handleConnectVPN(conn net.Conn, req models.Request, manager *Manager) {
-	uuidOrName, ok := req.Params["uuidOrName"].(string)
+	uuidOrName, ok := params.StringAlt(req.Params, "uuidOrName", "name", "uuid")
 	if !ok {
-		name, nameOk := req.Params["name"].(string)
+		log.Warnf("handleConnectVPN: missing uuidOrName/name/uuid parameter")
-		uuid, uuidOk := req.Params["uuid"].(string)
+		models.RespondError(conn, req.ID, "missing 'uuidOrName', 'name', or 'uuid' parameter")
-		if nameOk {
+		return
-			uuidOrName = name
-		} else if uuidOk {
-			uuidOrName = uuid
-		} else {
-			log.Warnf("handleConnectVPN: missing uuidOrName/name/uuid parameter")
-			models.RespondError(conn, req.ID, "missing 'uuidOrName', 'name', or 'uuid' parameter")
-			return
-		}
 	}
 
-	// Default to true - only allow one VPN connection at a time
+	singleActive := params.BoolOpt(req.Params, "singleActive", true)
-	singleActive := true
-	if sa, ok := req.Params["singleActive"].(bool); ok {
-		singleActive = sa
-	}
 
 	if err := manager.ConnectVPN(uuidOrName, singleActive); err != nil {
 		log.Warnf("handleConnectVPN: failed to connect: %v", err)
@@ -458,23 +404,15 @@ func handleConnectVPN(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "VPN connection initiated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "VPN connection initiated"})
 }
 
-func handleDisconnectVPN(conn net.Conn, req Request, manager *Manager) {
+func handleDisconnectVPN(conn net.Conn, req models.Request, manager *Manager) {
-	uuidOrName, ok := req.Params["uuidOrName"].(string)
+	uuidOrName, ok := params.StringAlt(req.Params, "uuidOrName", "name", "uuid")
 	if !ok {
-		name, nameOk := req.Params["name"].(string)
+		log.Warnf("handleDisconnectVPN: missing uuidOrName/name/uuid parameter")
-		uuid, uuidOk := req.Params["uuid"].(string)
+		models.RespondError(conn, req.ID, "missing 'uuidOrName', 'name', or 'uuid' parameter")
-		if nameOk {
+		return
-			uuidOrName = name
-		} else if uuidOk {
-			uuidOrName = uuid
-		} else {
-			log.Warnf("handleDisconnectVPN: missing uuidOrName/name/uuid parameter")
-			models.RespondError(conn, req.ID, "missing 'uuidOrName', 'name', or 'uuid' parameter")
-			return
-		}
 	}
 
 	if err := manager.DisconnectVPN(uuidOrName); err != nil {
@@ -483,27 +421,21 @@ func handleDisconnectVPN(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "VPN disconnected"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "VPN disconnected"})
 }
 
-func handleDisconnectAllVPN(conn net.Conn, req Request, manager *Manager) {
+func handleDisconnectAllVPN(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.DisconnectAllVPN(); err != nil {
 		log.Warnf("handleDisconnectAllVPN: failed: %v", err)
 		models.RespondError(conn, req.ID, fmt.Sprintf("failed to disconnect all VPNs: %v", err))
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "All VPNs disconnected"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "All VPNs disconnected"})
 }
 
-func handleClearVPNCredentials(conn net.Conn, req Request, manager *Manager) {
+func handleClearVPNCredentials(conn net.Conn, req models.Request, manager *Manager) {
-	uuidOrName, ok := req.Params["uuid"].(string)
+	uuidOrName, ok := params.StringAlt(req.Params, "uuid", "name", "uuidOrName")
-	if !ok {
-		uuidOrName, ok = req.Params["name"].(string)
-	}
-	if !ok {
-		uuidOrName, ok = req.Params["uuidOrName"].(string)
-	}
 	if !ok {
 		log.Warnf("handleClearVPNCredentials: missing uuidOrName/name/uuid parameter")
 		models.RespondError(conn, req.ID, "missing uuidOrName/name/uuid parameter")
@@ -516,19 +448,19 @@ func handleClearVPNCredentials(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "VPN credentials cleared"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "VPN credentials cleared"})
 }
 
-func handleSetWiFiAutoconnect(conn net.Conn, req Request, manager *Manager) {
+func handleSetWiFiAutoconnect(conn net.Conn, req models.Request, manager *Manager) {
-	ssid, ok := req.Params["ssid"].(string)
+	ssid, err := params.String(req.Params, "ssid")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'ssid' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	autoconnect, ok := req.Params["autoconnect"].(bool)
+	autoconnect, err := params.Bool(req.Params, "autoconnect")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'autoconnect' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -537,10 +469,10 @@ func handleSetWiFiAutoconnect(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "autoconnect updated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "autoconnect updated"})
 }
 
-func handleListVPNPlugins(conn net.Conn, req Request, manager *Manager) {
+func handleListVPNPlugins(conn net.Conn, req models.Request, manager *Manager) {
 	plugins, err := manager.ListVPNPlugins()
 	if err != nil {
 		log.Warnf("handleListVPNPlugins: failed to list plugins: %v", err)
@@ -551,17 +483,14 @@ func handleListVPNPlugins(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, plugins)
 }
 
-func handleImportVPN(conn net.Conn, req Request, manager *Manager) {
+func handleImportVPN(conn net.Conn, req models.Request, manager *Manager) {
-	filePath, ok := req.Params["file"].(string)
+	filePath, ok := params.StringAlt(req.Params, "file", "path")
-	if !ok {
-		filePath, ok = req.Params["path"].(string)
-	}
 	if !ok {
 		models.RespondError(conn, req.ID, "missing 'file' or 'path' parameter")
 		return
 	}
 
-	name, _ := req.Params["name"].(string)
+	name := params.StringOpt(req.Params, "name", "")
 
 	result, err := manager.ImportVPN(filePath, name)
 	if err != nil {
@@ -573,14 +502,8 @@ func handleImportVPN(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, result)
 }
 
-func handleGetVPNConfig(conn net.Conn, req Request, manager *Manager) {
+func handleGetVPNConfig(conn net.Conn, req models.Request, manager *Manager) {
-	uuidOrName, ok := req.Params["uuid"].(string)
+	uuidOrName, ok := params.StringAlt(req.Params, "uuid", "name", "uuidOrName")
-	if !ok {
-		uuidOrName, ok = req.Params["name"].(string)
-	}
-	if !ok {
-		uuidOrName, ok = req.Params["uuidOrName"].(string)
-	}
 	if !ok {
 		models.RespondError(conn, req.ID, "missing 'uuid', 'name', or 'uuidOrName' parameter")
 		return
@@ -596,10 +519,10 @@ func handleGetVPNConfig(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, config)
 }
 
-func handleUpdateVPNConfig(conn net.Conn, req Request, manager *Manager) {
+func handleUpdateVPNConfig(conn net.Conn, req models.Request, manager *Manager) {
-	connUUID, ok := req.Params["uuid"].(string)
+	connUUID, err := params.String(req.Params, "uuid")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing 'uuid' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -626,17 +549,11 @@ func handleUpdateVPNConfig(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "VPN config updated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "VPN config updated"})
 }
 
-func handleDeleteVPN(conn net.Conn, req Request, manager *Manager) {
+func handleDeleteVPN(conn net.Conn, req models.Request, manager *Manager) {
-	uuidOrName, ok := req.Params["uuid"].(string)
+	uuidOrName, ok := params.StringAlt(req.Params, "uuid", "name", "uuidOrName")
-	if !ok {
-		uuidOrName, ok = req.Params["name"].(string)
-	}
-	if !ok {
-		uuidOrName, ok = req.Params["uuidOrName"].(string)
-	}
 	if !ok {
 		models.RespondError(conn, req.ID, "missing 'uuid', 'name', or 'uuidOrName' parameter")
 		return
@@ -648,23 +565,19 @@ func handleDeleteVPN(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "VPN deleted"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "VPN deleted"})
 }
 
-func handleSetVPNCredentials(conn net.Conn, req Request, manager *Manager) {
+func handleSetVPNCredentials(conn net.Conn, req models.Request, manager *Manager) {
-	connUUID, ok := req.Params["uuid"].(string)
+	connUUID, err := params.String(req.Params, "uuid")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing 'uuid' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	username, _ := req.Params["username"].(string)
+	username := params.StringOpt(req.Params, "username", "")
-	password, _ := req.Params["password"].(string)
+	password := params.StringOpt(req.Params, "password", "")
-
+	save := params.BoolOpt(req.Params, "save", true)
-	save := true
-	if saveParam, ok := req.Params["save"].(bool); ok {
-		save = saveParam
-	}
 
 	if err := manager.SetVPNCredentials(connUUID, username, password, save); err != nil {
 		log.Warnf("handleSetVPNCredentials: failed to set credentials: %v", err)
@@ -672,5 +585,5 @@ func handleSetVPNCredentials(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "VPN credentials set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "VPN credentials set"})
 }

core/internal/server/network/handlers_test.go

@@ -53,10 +53,10 @@ func TestRespondError_Network(t *testing.T) {
 
 func TestRespond_Network(t *testing.T) {
 	conn := newMockNetConn()
-	result := SuccessResult{Success: true, Message: "test"}
+	result := models.SuccessResult{Success: true, Message: "test"}
 	models.Respond(conn, 123, result)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 	require.NoError(t, err)
 
@@ -77,7 +77,7 @@ func TestHandleGetState(t *testing.T) {
 	}
 
 	conn := newMockNetConn()
-	req := Request{ID: 123, Method: "network.getState"}
+	req := models.Request{ID: 123, Method: "network.getState"}
 
 	handleGetState(conn, req, manager)
 
@@ -103,7 +103,7 @@ func TestHandleGetWiFiNetworks(t *testing.T) {
 	}
 
 	conn := newMockNetConn()
-	req := Request{ID: 123, Method: "network.wifi.networks"}
+	req := models.Request{ID: 123, Method: "network.wifi.networks"}
 
 	handleGetWiFiNetworks(conn, req, manager)
 
@@ -125,7 +125,7 @@ func TestHandleConnectWiFi(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "network.wifi.connect",
 			Params: map[string]any{},
@@ -149,7 +149,7 @@ func TestHandleSetPreference(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "network.preference.set",
 			Params: map[string]any{},
@@ -173,7 +173,7 @@ func TestHandleGetNetworkInfo(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "network.info",
 			Params: map[string]any{},
@@ -199,7 +199,7 @@ func TestHandleRequest(t *testing.T) {
 
 	t.Run("unknown method", func(t *testing.T) {
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "network.unknown",
 		}
@@ -216,7 +216,7 @@ func TestHandleRequest(t *testing.T) {
 
 	t.Run("valid method - getState", func(t *testing.T) {
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "network.getState",
 		}

core/internal/server/params/params.go

@@ -0,0 +1,113 @@
+package params
+
+import "fmt"
+
+func Get[T any](params map[string]any, key string) (T, error) {
+	val, ok := params[key].(T)
+	if !ok {
+		var zero T
+		return zero, fmt.Errorf("missing or invalid '%s' parameter", key)
+	}
+	return val, nil
+}
+
+func GetOpt[T any](params map[string]any, key string, def T) T {
+	if val, ok := params[key].(T); ok {
+		return val
+	}
+	return def
+}
+
+func String(params map[string]any, key string) (string, error) {
+	return Get[string](params, key)
+}
+
+func StringNonEmpty(params map[string]any, key string) (string, error) {
+	val, err := Get[string](params, key)
+	if err != nil || val == "" {
+		return "", fmt.Errorf("missing or invalid '%s' parameter", key)
+	}
+	return val, nil
+}
+
+func StringOpt(params map[string]any, key string, def string) string {
+	return GetOpt(params, key, def)
+}
+
+func Int(params map[string]any, key string) (int, error) {
+	val, err := Get[float64](params, key)
+	if err != nil {
+		return 0, err
+	}
+	return int(val), nil
+}
+
+func IntOpt(params map[string]any, key string, def int) int {
+	if val, ok := params[key].(float64); ok {
+		return int(val)
+	}
+	return def
+}
+
+func Float(params map[string]any, key string) (float64, error) {
+	return Get[float64](params, key)
+}
+
+func FloatOpt(params map[string]any, key string, def float64) float64 {
+	return GetOpt(params, key, def)
+}
+
+func Bool(params map[string]any, key string) (bool, error) {
+	return Get[bool](params, key)
+}
+
+func BoolOpt(params map[string]any, key string, def bool) bool {
+	return GetOpt(params, key, def)
+}
+
+func StringMap(params map[string]any, key string) (map[string]string, error) {
+	rawMap, err := Get[map[string]any](params, key)
+	if err != nil {
+		return nil, err
+	}
+	result := make(map[string]string)
+	for k, v := range rawMap {
+		if str, ok := v.(string); ok {
+			result[k] = str
+		}
+	}
+	return result, nil
+}
+
+func StringMapOpt(params map[string]any, key string) map[string]string {
+	rawMap, ok := params[key].(map[string]any)
+	if !ok {
+		return nil
+	}
+	result := make(map[string]string)
+	for k, v := range rawMap {
+		if str, ok := v.(string); ok {
+			result[k] = str
+		}
+	}
+	return result
+}
+
+func Any(params map[string]any, key string) (any, bool) {
+	val, ok := params[key]
+	return val, ok
+}
+
+func AnyMap(params map[string]any, key string) (map[string]any, bool) {
+	val, ok := params[key].(map[string]any)
+	return val, ok
+}
+
+func StringAlt(params map[string]any, keys ...string) (string, bool) {
+	for _, key := range keys {
+		if val, ok := params[key].(string); ok {
+			return val, true
+		}
+	}
+	return "", false
+}

core/internal/server/params/params_test.go

@@ -0,0 +1,154 @@
+package params
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGet(t *testing.T) {
+	p := map[string]any{"key": "value"}
+	val, err := Get[string](p, "key")
+	assert.NoError(t, err)
+	assert.Equal(t, "value", val)
+
+	_, err = Get[string](p, "missing")
+	assert.Error(t, err)
+
+	_, err = Get[int](p, "key")
+	assert.Error(t, err)
+}
+
+func TestGetOpt(t *testing.T) {
+	p := map[string]any{"key": "value"}
+	assert.Equal(t, "value", GetOpt(p, "key", "default"))
+	assert.Equal(t, "default", GetOpt(p, "missing", "default"))
+}
+
+func TestString(t *testing.T) {
+	p := map[string]any{"s": "hello", "n": 123}
+	val, err := String(p, "s")
+	assert.NoError(t, err)
+	assert.Equal(t, "hello", val)
+
+	_, err = String(p, "n")
+	assert.Error(t, err)
+}
+
+func TestStringNonEmpty(t *testing.T) {
+	p := map[string]any{"s": "hello", "empty": ""}
+	val, err := StringNonEmpty(p, "s")
+	assert.NoError(t, err)
+	assert.Equal(t, "hello", val)
+
+	_, err = StringNonEmpty(p, "empty")
+	assert.Error(t, err)
+
+	_, err = StringNonEmpty(p, "missing")
+	assert.Error(t, err)
+}
+
+func TestStringOpt(t *testing.T) {
+	p := map[string]any{"s": "hello"}
+	assert.Equal(t, "hello", StringOpt(p, "s", "default"))
+	assert.Equal(t, "default", StringOpt(p, "missing", "default"))
+}
+
+func TestInt(t *testing.T) {
+	p := map[string]any{"n": float64(42), "s": "str"}
+	val, err := Int(p, "n")
+	assert.NoError(t, err)
+	assert.Equal(t, 42, val)
+
+	_, err = Int(p, "s")
+	assert.Error(t, err)
+}
+
+func TestIntOpt(t *testing.T) {
+	p := map[string]any{"n": float64(42)}
+	assert.Equal(t, 42, IntOpt(p, "n", 0))
+	assert.Equal(t, 99, IntOpt(p, "missing", 99))
+}
+
+func TestFloat(t *testing.T) {
+	p := map[string]any{"f": 3.14, "s": "str"}
+	val, err := Float(p, "f")
+	assert.NoError(t, err)
+	assert.Equal(t, 3.14, val)
+
+	_, err = Float(p, "s")
+	assert.Error(t, err)
+}
+
+func TestFloatOpt(t *testing.T) {
+	p := map[string]any{"f": 3.14}
+	assert.Equal(t, 3.14, FloatOpt(p, "f", 0))
+	assert.Equal(t, 1.0, FloatOpt(p, "missing", 1.0))
+}
+
+func TestBool(t *testing.T) {
+	p := map[string]any{"b": true, "s": "str"}
+	val, err := Bool(p, "b")
+	assert.NoError(t, err)
+	assert.True(t, val)
+
+	_, err = Bool(p, "s")
+	assert.Error(t, err)
+}
+
+func TestBoolOpt(t *testing.T) {
+	p := map[string]any{"b": true}
+	assert.True(t, BoolOpt(p, "b", false))
+	assert.True(t, BoolOpt(p, "missing", true))
+}
+
+func TestStringMap(t *testing.T) {
+	p := map[string]any{
+		"m": map[string]any{"a": "1", "b": "2", "c": 3},
+	}
+	val, err := StringMap(p, "m")
+	assert.NoError(t, err)
+	assert.Equal(t, map[string]string{"a": "1", "b": "2"}, val)
+
+	_, err = StringMap(p, "missing")
+	assert.Error(t, err)
+}
+
+func TestStringMapOpt(t *testing.T) {
+	p := map[string]any{
+		"m": map[string]any{"a": "1"},
+	}
+	assert.Equal(t, map[string]string{"a": "1"}, StringMapOpt(p, "m"))
+	assert.Nil(t, StringMapOpt(p, "missing"))
+}
+
+func TestAny(t *testing.T) {
+	p := map[string]any{"k": 123}
+	val, ok := Any(p, "k")
+	assert.True(t, ok)
+	assert.Equal(t, 123, val)
+
+	_, ok = Any(p, "missing")
+	assert.False(t, ok)
+}
+
+func TestAnyMap(t *testing.T) {
+	inner := map[string]any{"nested": true}
+	p := map[string]any{"m": inner}
+	val, ok := AnyMap(p, "m")
+	assert.True(t, ok)
+	assert.Equal(t, inner, val)
+
+	_, ok = AnyMap(p, "missing")
+	assert.False(t, ok)
+}
+
+func TestStringAlt(t *testing.T) {
+	p := map[string]any{"b": "found"}
+	val, ok := StringAlt(p, "a", "b", "c")
+	assert.True(t, ok)
+	assert.Equal(t, "found", val)
+
+	_, ok = StringAlt(p, "x", "y")
+	assert.False(t, ok)
+}

core/internal/server/router.go

@@ -27,12 +27,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "network manager not initialized")
 			return
 		}
-		netReq := network.Request{
+		network.HandleRequest(conn, req, networkManager)
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		network.HandleRequest(conn, netReq, networkManager)
 		return
 	}
 
@@ -46,12 +41,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "loginctl manager not initialized")
 			return
 		}
-		loginReq := loginctl.Request{
+		loginctl.HandleRequest(conn, req, loginctlManager)
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		loginctl.HandleRequest(conn, loginReq, loginctlManager)
 		return
 	}
 
@@ -60,12 +50,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "freedesktop manager not initialized")
 			return
 		}
-		freedeskReq := freedesktop.Request{
+		freedesktop.HandleRequest(conn, req, freedesktopManager)
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		freedesktop.HandleRequest(conn, freedeskReq, freedesktopManager)
 		return
 	}
 
@@ -74,12 +59,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "wayland manager not initialized")
 			return
 		}
-		waylandReq := wayland.Request{
+		wayland.HandleRequest(conn, req, waylandManager)
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		wayland.HandleRequest(conn, waylandReq, waylandManager)
 		return
 	}
 
@@ -88,12 +68,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "bluetooth manager not initialized")
 			return
 		}
-		bluezReq := bluez.Request{
+		bluez.HandleRequest(conn, req, bluezManager)
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		bluez.HandleRequest(conn, bluezReq, bluezManager)
 		return
 	}
 
@@ -102,12 +77,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "apppicker manager not initialized")
 			return
 		}
-		appPickerReq := apppicker.Request{
+		apppicker.HandleRequest(conn, req, appPickerManager)
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		apppicker.HandleRequest(conn, appPickerReq, appPickerManager)
 		return
 	}
 
@@ -116,12 +86,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "CUPS manager not initialized")
 			return
 		}
-		cupsReq := cups.Request{
+		cups.HandleRequest(conn, req, cupsManager)
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		cups.HandleRequest(conn, cupsReq, cupsManager)
 		return
 	}
 
@@ -130,12 +95,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "dwl manager not initialized")
 			return
 		}
-		dwlReq := dwl.Request{
+		dwl.HandleRequest(conn, req, dwlManager)
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		dwl.HandleRequest(conn, dwlReq, dwlManager)
 		return
 	}
 
@@ -144,12 +104,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "brightness manager not initialized")
 			return
 		}
-		brightnessReq := brightness.Request{
+		brightness.HandleRequest(conn, req, brightnessManager)
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		brightness.HandleRequest(conn, brightnessReq, brightnessManager)
 		return
 	}
 
@@ -170,12 +125,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 				return
 			}
 		}
-		extWorkspaceReq := extworkspace.Request{
+		extworkspace.HandleRequest(conn, req, extWorkspaceManager)
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		extworkspace.HandleRequest(conn, extWorkspaceReq, extWorkspaceManager)
 		return
 	}
 
@@ -184,12 +134,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "wlroutput manager not initialized")
 			return
 		}
-		wlrOutputReq := wlroutput.Request{
+		wlroutput.HandleRequest(conn, req, wlrOutputManager)
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		wlroutput.HandleRequest(conn, wlrOutputReq, wlrOutputManager)
 		return
 	}
 
@@ -198,12 +143,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "evdev manager not initialized")
 			return
 		}
-		evdevReq := evdev.Request{
+		evdev.HandleRequest(conn, req, evdevManager)
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		evdev.HandleRequest(conn, evdevReq, evdevManager)
 		return
 	}
 

core/internal/server/wayland/handlers.go

@@ -7,20 +7,10 @@ import (
 	"time"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/params"
 )
 
-type Request struct {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
-	ID     int            `json:"id,omitempty"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params,omitempty"`
-}
-
-type SuccessResult struct {
-	Success bool   `json:"success"`
-	Message string `json:"message"`
-}
-
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	if manager == nil {
 		models.RespondError(conn, req.ID, "wayland manager not initialized")
 		return
@@ -48,26 +38,27 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleGetState(conn net.Conn, req Request, manager *Manager) {
+func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
-	state := manager.GetState()
+	models.Respond(conn, req.ID, manager.GetState())
-	models.Respond(conn, req.ID, state)
 }
 
-func handleSetTemperature(conn net.Conn, req Request, manager *Manager) {
+func handleSetTemperature(conn net.Conn, req models.Request, manager *Manager) {
 	var lowTemp, highTemp int
 
 	if temp, ok := req.Params["temp"].(float64); ok {
 		lowTemp = int(temp)
 		highTemp = int(temp)
 	} else {
-		low, okLow := req.Params["low"].(float64)
+		low, err := params.Float(req.Params, "low")
-		high, okHigh := req.Params["high"].(float64)
+		if err != nil {
-
+			models.RespondError(conn, req.ID, "missing temperature parameters (provide 'temp' or both 'low' and 'high')")
-		if !okLow || !okHigh {
+			return
+		}
+		high, err := params.Float(req.Params, "high")
+		if err != nil {
 			models.RespondError(conn, req.ID, "missing temperature parameters (provide 'temp' or both 'low' and 'high')")
 			return
 		}
-
 		lowTemp = int(low)
 		highTemp = int(high)
 	}
@@ -77,19 +68,19 @@ func handleSetTemperature(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "temperature set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "temperature set"})
 }
 
-func handleSetLocation(conn net.Conn, req Request, manager *Manager) {
+func handleSetLocation(conn net.Conn, req models.Request, manager *Manager) {
-	lat, ok := req.Params["latitude"].(float64)
+	lat, err := params.Float(req.Params, "latitude")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'latitude' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	lon, ok := req.Params["longitude"].(float64)
+	lon, err := params.Float(req.Params, "longitude")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'longitude' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -98,30 +89,30 @@ func handleSetLocation(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "location set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "location set"})
 }
 
-func handleSetManualTimes(conn net.Conn, req Request, manager *Manager) {
+func handleSetManualTimes(conn net.Conn, req models.Request, manager *Manager) {
 	sunriseParam := req.Params["sunrise"]
 	sunsetParam := req.Params["sunset"]
 
 	if sunriseParam == nil || sunsetParam == nil {
 		manager.ClearManualTimes()
-		models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "manual times cleared"})
+		models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "manual times cleared"})
 		return
 	}
 
 	sunriseStr, ok := sunriseParam.(string)
 	if !ok || sunriseStr == "" {
 		manager.ClearManualTimes()
-		models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "manual times cleared"})
+		models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "manual times cleared"})
 		return
 	}
 
 	sunsetStr, ok := sunsetParam.(string)
 	if !ok || sunsetStr == "" {
 		manager.ClearManualTimes()
-		models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "manual times cleared"})
+		models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "manual times cleared"})
 		return
 	}
 
@@ -142,24 +133,24 @@ func handleSetManualTimes(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "manual times set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "manual times set"})
 }
 
-func handleSetUseIPLocation(conn net.Conn, req Request, manager *Manager) {
+func handleSetUseIPLocation(conn net.Conn, req models.Request, manager *Manager) {
-	use, ok := req.Params["use"].(bool)
+	use, err := params.Bool(req.Params, "use")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'use' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
 	manager.SetUseIPLocation(use)
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "IP location preference set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "IP location preference set"})
 }
 
-func handleSetGamma(conn net.Conn, req Request, manager *Manager) {
+func handleSetGamma(conn net.Conn, req models.Request, manager *Manager) {
-	gamma, ok := req.Params["gamma"].(float64)
+	gamma, err := params.Float(req.Params, "gamma")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'gamma' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -168,21 +159,21 @@ func handleSetGamma(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "gamma set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "gamma set"})
 }
 
-func handleSetEnabled(conn net.Conn, req Request, manager *Manager) {
+func handleSetEnabled(conn net.Conn, req models.Request, manager *Manager) {
-	enabled, ok := req.Params["enabled"].(bool)
+	enabled, err := params.Bool(req.Params, "enabled")
-	if !ok {
+	if err != nil {
-		models.RespondError(conn, req.ID, "missing or invalid 'enabled' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
 	manager.SetEnabled(enabled)
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "enabled state set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "enabled state set"})
 }
 
-func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
+func handleSubscribe(conn net.Conn, req models.Request, manager *Manager) {
 	clientID := fmt.Sprintf("client-%p", conn)
 	stateChan := manager.Subscribe(clientID)
 	defer manager.Unsubscribe(clientID)

core/internal/server/wlroutput/handlers.go

@@ -11,17 +11,6 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
 )
 
-type Request struct {
-	ID     int            `json:"id,omitempty"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params,omitempty"`
-}
-
-type SuccessResult struct {
-	Success bool   `json:"success"`
-	Message string `json:"message"`
-}
-
 type HeadConfig struct {
 	Name       string  `json:"name"`
 	Enabled    bool    `json:"enabled"`
@@ -42,7 +31,7 @@ type ConfigurationRequest struct {
 	Test  bool         `json:"test"`
 }
 
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 	if manager == nil {
 		models.RespondError(conn, req.ID, "wlroutput manager not initialized")
 		return
@@ -62,12 +51,11 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleGetState(conn net.Conn, req Request, manager *Manager) {
+func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
-	state := manager.GetState()
+	models.Respond(conn, req.ID, manager.GetState())
-	models.Respond(conn, req.ID, state)
 }
 
-func handleApplyConfiguration(conn net.Conn, req Request, manager *Manager, test bool) {
+func handleApplyConfiguration(conn net.Conn, req models.Request, manager *Manager, test bool) {
 	headsParam, ok := req.Params["heads"]
 	if !ok {
 		models.RespondError(conn, req.ID, "missing 'heads' parameter")
@@ -95,10 +83,10 @@ func handleApplyConfiguration(conn net.Conn, req Request, manager *Manager, test
 	if test {
 		msg = "configuration test succeeded"
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: msg})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: msg})
 }
 
-func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
+func handleSubscribe(conn net.Conn, req models.Request, manager *Manager) {
 	clientID := fmt.Sprintf("client-%p", conn)
 	stateChan := manager.Subscribe(clientID)
 	defer manager.Unsubscribe(clientID)