feat: add POST /PiShock/Operate endpoint and health checks

- Add Operate endpoint to PsWebApiController matching the ps.pishock.com
  non-legacy operate API (same share code based auth, same control flow)
- Add HealthWebApiController with /Health/Check (200) and /Health/Server (204)
  endpoints to satisfy apps that health-check the PiShock API
- Register health controller in InterceptionService

Author: LucHeart

Interception/InterceptionService.cs

@@ -36,13 +36,15 @@ public async Task StartAsync()
 
         var operateController = ActivatorUtilities.CreateInstance<DoWebApiController>(serviceProvider);
         var psController = ActivatorUtilities.CreateInstance<PsWebApiController>(serviceProvider);
+        var healthController = new HealthWebApiController();
 
         _server = new WebServer(o => o
                     .WithUrlPrefix($"https://*:{port}/")
                     .WithMode(HttpListenerMode.EmbedIO)
                     .WithCertificate(cert))
                 .WithWebApi("/api", m => m.WithController(() => operateController))
                 .WithWebApi("/PiShock", m => m.WithController(() => psController))
+                .WithWebApi("/Health", m => m.WithController(() => healthController))
             ;
 
         _ = _server.RunAsync();

Interception/Server/HealthWebApiController.cs

@@ -0,0 +1,23 @@
+using System.Text;
+using EmbedIO;
+using EmbedIO.Routing;
+using EmbedIO.WebApi;
+
+namespace OpenShock.Desktop.Modules.Interception.Server;
+
+public sealed class HealthWebApiController : WebApiController
+{
+    [Route(HttpVerbs.Get, "/Check")]
+    public async Task Check()
+    {
+        HttpContext.Response.StatusCode = 200;
+        await HttpContext.SendStringAsync("OK", "text/plain", Encoding.UTF8);
+    }
+
+    [Route(HttpVerbs.Get, "/Server")]
+    public Task Server()
+    {
+        HttpContext.Response.StatusCode = 204;
+        return Task.CompletedTask;
+    }
+}

Interception/Server/PsWebApiController.cs

@@ -5,23 +5,110 @@
 using EmbedIO.WebApi;
 using Microsoft.Extensions.Logging;
 using OpenShock.Desktop.ModuleBase.Api;
+using OpenShock.Desktop.ModuleBase.Models;
 
 namespace OpenShock.Desktop.Modules.Interception.Server;
 
 public sealed class PsWebApiController : WebApiController
 {
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        PropertyNameCaseInsensitive = true
+    };
+
     private readonly ILogger<PsWebApiController> _logger;
+    private readonly IOpenShockControl _openShockControl;
     private readonly IOpenShockData _openShockData;
     private readonly InterceptionService _service;
 
-    public PsWebApiController(InterceptionService service, IOpenShockData openShockData,
-        ILogger<PsWebApiController> logger)
+    public PsWebApiController(InterceptionService service, IOpenShockControl openShockControl,
+        IOpenShockData openShockData, ILogger<PsWebApiController> logger)
     {
         _service = service;
+        _openShockControl = openShockControl;
         _openShockData = openShockData;
         _logger = logger;
     }
 
+    [Route(HttpVerbs.Post, "/Operate")]
+    public async Task Operate()
+    {
+        using var reader = new StreamReader(HttpContext.Request.InputStream);
+        var body = await reader.ReadToEndAsync();
+
+        PiShockRequest? request;
+        try
+        {
+            request = JsonSerializer.Deserialize<PiShockRequest>(body, JsonOptions);
+        }
+        catch
+        {
+            _logger.LogError("Error parsing JSON body: {Body}", body);
+            HttpContext.Response.StatusCode = 400;
+            await HttpContext.SendStringAsync("Invalid JSON", "text/plain", Encoding.UTF8);
+            return;
+        }
+
+        if (request?.Code == null)
+        {
+            _logger.LogError("Missing share code in request: {Body}", body);
+            HttpContext.Response.StatusCode = 400;
+            await HttpContext.SendStringAsync("Missing share code", "text/plain", Encoding.UTF8);
+            return;
+        }
+
+        if (!_service.Config.ShareCodeMappings.TryGetValue(request.Code, out var mapping))
+        {
+            _logger.LogError("Share code not mapped to any shocker: {Code}", request.Code);
+            await HttpContext.SendStringAsync("This code doesn't exist.", "text/plain", Encoding.UTF8);
+            return;
+        }
+
+        if (mapping.ShockerIds.Count == 0)
+        {
+            _logger.LogError("Share code has no shockers configured: {Code}", request.Code);
+            await HttpContext.SendStringAsync("This code doesn't exist.", "text/plain", Encoding.UTF8);
+            return;
+        }
+
+        var controlType = request.Op switch
+        {
+            0 => ControlType.Shock,
+            1 => ControlType.Vibrate,
+            2 => ControlType.Sound,
+            _ => ControlType.Vibrate
+        };
+
+        var durationMs = (ushort)Math.Clamp(request.Duration * 1000, mapping.MinDuration * 1000, mapping.MaxDuration * 1000);
+        var intensity = (byte)Math.Clamp(request.Intensity, mapping.MinIntensity, mapping.MaxIntensity);
+
+        if (request.Intensity <= 0) controlType = ControlType.Stop;
+
+        var controls = mapping.ShockerIds.Select(id => new ShockerControl
+        {
+            Id = id,
+            Type = controlType,
+            Intensity = intensity,
+            Duration = durationMs
+        }).ToArray();
+
+        var customName = request.Name ?? request.Username ?? "PiShock Interception";
+
+        try
+        {
+            await _openShockControl.Control(controls, customName);
+            _logger.LogInformation(
+                "PiShock Ps API Operate: {ControlType} {Intensity}% for {Duration}s on {ShockerCount} shocker(s) by {Name}",
+                controlType, intensity, durationMs / 1000.0, controls.Length, customName);
+            await HttpContext.SendStringAsync("Operation Succeeded.", "text/plain", Encoding.UTF8);
+        }
+        catch (Exception ex)
+        {
+            HttpContext.Response.StatusCode = 500;
+            await HttpContext.SendStringAsync(ex.Message, "text/plain", Encoding.UTF8);
+        }
+    }
+
     [Route(HttpVerbs.Get, "/GetUserDevices")]
     public async Task GetUserDevices()
     {