better port names, stability updates

Author: LucHeart

LocalRelay/Config/SerialConfig.cs

@@ -1,7 +1,9 @@
-namespace OpenShock.LocalRelay.Config;
+namespace OpenShock.LocalRelay.Config;
 
 public sealed class SerialConfig
 {
     public bool AutoConnect { get; set; } = true;
     public string? Port { get; set; } = null;
+    public ushort? Vid { get; set; } = null;
+    public ushort? Pid { get; set; } = null;
 }

LocalRelay/LocalRelay.csproj

@@ -8,9 +8,9 @@
         <AssemblyName>OpenShock.LocalRelay</AssemblyName>
         <RootNamespace>OpenShock.LocalRelay</RootNamespace>
         <Company>OpenShock</Company>
-        <AssemblyVersion>1.0.0.0</AssemblyVersion>
-        <ApplicationTitle>LocalRelay</ApplicationTitle>
-        <Version>1.0.0</Version>
+        <AssemblyVersion>1.1.0.0</AssemblyVersion>
+        
+        <Version>1.1.0</Version>
         <Product>LocalRelay</Product>
         <TargetFramework>net10.0</TargetFramework>
 

LocalRelay/Models/Serial/SerialPortInfo.cs

@@ -0,0 +1,3 @@
+namespace OpenShock.LocalRelay.Models.Serial;
+
+public sealed record SerialPortInfo(string Port, string Name, ushort? Vid, ushort? Pid);

LocalRelay/Services/FlowManager.cs

@@ -1,4 +1,4 @@
-using LucHeart.WebsocketLibrary;
+using LucHeart.WebsocketLibrary;
 using Microsoft.Extensions.Logging;
 using OpenShock.Desktop.ModuleBase.Api;
 using OpenShock.Desktop.ModuleBase.Config;
@@ -18,16 +18,17 @@ public sealed class FlowManager
     private readonly ILogger<DeviceConnection> _deviceConnectionLogger;
     private readonly ILogger<SerialPortClient> _serialPortClientLogger;
     private readonly IOpenShockService _openShockService;
+    private readonly SerialService _serialService;
 
     public Guid HubId { get; private set; } = Guid.Empty;
 
     public DeviceConnection? DeviceConnection { get; private set; } = null;
     public SerialPortClient? SerialPortClient { get; private set; } = null;
-    
+
     public IAsyncMinimalEventObservable OnConsoleBufferUpdate => _onConsoleBufferUpdate;
     private readonly AsyncMinimalEvent _onConsoleBufferUpdate = new();
-    
-    
+
+
     private readonly AsyncUpdatableVariable<WebsocketConnectionState> _state =
         new(WebsocketConnectionState.Disconnected);
     public IAsyncUpdatable<WebsocketConnectionState> State => _state;
@@ -37,46 +38,76 @@ public FlowManager(
         ILogger<FlowManager> logger,
         ILogger<DeviceConnection> deviceConnectionLogger,
         ILogger<SerialPortClient> serialPortClientLogger,
-        IOpenShockService openShockService)
+        IOpenShockService openShockService,
+        SerialService serialService)
     {
         _config = config;
         _logger = logger;
         _deviceConnectionLogger = deviceConnectionLogger;
         _serialPortClientLogger = serialPortClientLogger;
         _openShockService = openShockService;
+        _serialService = serialService;
     }
 
     public async Task LoadConfigAndStart()
     {
         if (_config.Config.Hub.Hub != null)
             await SelectedDeviceChanged(_config.Config.Hub.Hub.Value);
-        
+
         var serialConfig = _config.Config.Serial;
 
         if (serialConfig.AutoConnect)
         {
+            await AutoConnectSerialPort();
+        }
+    }
+
+    private async Task AutoConnectSerialPort()
+    {
+        var serialConfig = _config.Config.Serial;
+
+        // Try to find the device by VID/PID first
+        if (serialConfig.Vid != null && serialConfig.Pid != null)
+        {
+            var match = _serialService.FindPortByVidPid(serialConfig.Vid.Value, serialConfig.Pid.Value);
+            if (match != null)
+            {
+                _logger.LogInformation("Auto-connecting to {Name} on {Port} (VID:{Vid:X4} PID:{Pid:X4})",
+                    match.Name, match.Port, match.Vid, match.Pid);
+                await ConnectSerialPort(match.Port);
+                return;
+            }
+
+            _logger.LogWarning("Could not find serial device with VID:{Vid:X4} PID:{Pid:X4}",
+                serialConfig.Vid.Value, serialConfig.Pid.Value);
+        }
+
+        // Fallback to saved port name
+        if (!string.IsNullOrWhiteSpace(serialConfig.Port))
+        {
+            _logger.LogInformation("Falling back to saved port {Port}", serialConfig.Port);
             await ConnectSerialPort(serialConfig.Port);
         }
     }
-    
+
     public async Task SelectedDeviceChanged(Guid id)
     {
         _config.Config.Hub.Hub = id;
         await _config.Save();
-        
+
         HubId = id;
-        
+
         if (HubId == Guid.Empty)
         {
             _logger.LogError("Id is empty, stopping connection");
             await StopHubConnection();
             return;
         }
-        
+
         _logger.LogInformation("Selected device changed to {Id}", id);
         var deviceDetails = await _openShockService.Api.GetHub(id);
 
-        
+
         if (deviceDetails.IsT0)
         {
             var token = deviceDetails.AsT0.Value.Token;
@@ -85,14 +116,14 @@ public async Task SelectedDeviceChanged(Guid id)
                 _logger.LogError("Token is null or empty, make sure your api token has device.auth permission");
                 return;
             }
-            
+
             _logger.LogDebug("Starting device connection");
 
             await StartHubConnection(id, token);
             return;
         }
 
-       
+
         deviceDetails.Switch(success => {}, found =>
         {
             _logger.LogError("Hub not found");
@@ -101,7 +132,7 @@ public async Task SelectedDeviceChanged(Guid id)
         {
             _logger.LogError("Unauthorized, make sure your logged in");
         });
-        
+
         throw new Exception("Unhandled OneOf type");
     }
 
@@ -117,7 +148,7 @@ private async Task<bool> StopHubConnection()
     private async Task StartHubConnection(Guid id, string authToken)
     {
         await StopHubConnection();
-        
+
         DeviceConnection =
             new DeviceConnection(_openShockService.Auth.BackendBaseUri, authToken, _deviceConnectionLogger);
         DeviceConnection.OnControlMessage += OnControlMessage;
@@ -144,22 +175,87 @@ private async Task OnControlMessage(ShockerCommandList shockerCommandList)
         }));
         await Task.WhenAll(transmitTasks);
     }
-    
+
     private IAsyncDisposable? _onConsoleBufferUpdateDisposable = null;
+    private IAsyncDisposable? _onCloseDisposable = null;
+
+    public async Task ConnectSerialPort(SerialPortInfo portInfo)
+    {
+        // Save VID/PID and port to config
+        var serialConfig = _config.Config.Serial;
+        serialConfig.Port = portInfo.Port;
+        serialConfig.Vid = portInfo.Vid;
+        serialConfig.Pid = portInfo.Pid;
+        await _config.Save();
+
+        await ConnectSerialPort(portInfo.Port);
+    }
 
     public async Task ConnectSerialPort(string? portName)
     {
         if (SerialPortClient != null)
         {
-            if(_onConsoleBufferUpdateDisposable != null) await _onConsoleBufferUpdateDisposable.DisposeAsync();
+            if (_onCloseDisposable != null) await _onCloseDisposable.DisposeAsync();
+            if (_onConsoleBufferUpdateDisposable != null) await _onConsoleBufferUpdateDisposable.DisposeAsync();
             await SerialPortClient.DisposeAsync();
             SerialPortClient = null;
         }
-        
-        if(string.IsNullOrWhiteSpace(portName)) return;
-        
+
+        if (string.IsNullOrWhiteSpace(portName)) return;
+
         SerialPortClient = new SerialPortClient(_serialPortClientLogger, portName);
         _onConsoleBufferUpdateDisposable = await SerialPortClient.OnConsoleBufferUpdate.SubscribeAsync(_onConsoleBufferUpdate.InvokeAsyncParallel);
+        _onCloseDisposable = await SerialPortClient.OnClose.SubscribeAsync(OnSerialPortClosed);
         await SerialPortClient.Open();
     }
+
+    private async Task OnSerialPortClosed()
+    {
+        _logger.LogWarning("Serial port closed, attempting to reconnect...");
+
+        var serialConfig = _config.Config.Serial;
+        if (!serialConfig.AutoConnect) return;
+
+        // Retry reconnection with backoff
+        for (var attempt = 0; attempt < 10; attempt++)
+        {
+            await Task.Delay(TimeSpan.FromSeconds(Math.Min(2 * (attempt + 1), 10)));
+
+            // Try VID/PID match first
+            if (serialConfig.Vid != null && serialConfig.Pid != null)
+            {
+                var match = _serialService.FindPortByVidPid(serialConfig.Vid.Value, serialConfig.Pid.Value);
+                if (match != null)
+                {
+                    _logger.LogInformation("Reconnecting to {Name} on {Port}", match.Name, match.Port);
+                    try
+                    {
+                        await ConnectSerialPort(match.Port);
+                        return;
+                    }
+                    catch (Exception e)
+                    {
+                        _logger.LogError(e, "Failed to reconnect on attempt {Attempt}", attempt + 1);
+                    }
+
+                    continue;
+                }
+            }
+
+            _logger.LogDebug("Device not found, retrying... (attempt {Attempt}/10)", attempt + 1);
+        }
+
+        _logger.LogError("Failed to reconnect to serial device after 10 attempts");
+    }
+
+    public async Task DisconnectSerialPort()
+    {
+        var serialConfig = _config.Config.Serial;
+        serialConfig.Port = null;
+        serialConfig.Vid = null;
+        serialConfig.Pid = null;
+        await _config.Save();
+
+        await ConnectSerialPort((string?)null);
+    }
 }