fix(session): re-send auto-login on automatic reconnect

When a session dropped and TelnetConnection reconnected on its own, the stored
connect string was never re-sent — the launcher only sent it once, on the
initial connect. So an auto-reconnected session was left sitting at the server's
login screen (unauthenticated), and with an empty input box the Send button
stays disabled, leaving the user stuck.

Move the auto-login into the Session: it now runs on every transition into
Connected (initial connect AND each auto-reconnect) via a provider that resolves
the character's stored connect string from the secret store on demand. The
launcher supplies the provider and no longer sends the credential itself.

Adds SessionSendsAutoLoginOnConnectAndReconnect and
SessionWithoutAutoLoginSendsNothingOnConnect; full Core suite (196) passes.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HHCRc5CJ6595iMzEgYYdQp

Author: HarryCordewener

src/SharpClient.Core/Sessions/Session.cs

@@ -19,6 +19,12 @@ public sealed class Session : ISession
     private readonly INotifier? _notifier;
     private readonly ISessionHistory? _history;
 
+    // Auto-login command provider (resolves the character's stored connect string). Invoked on
+    // every transition into Connected so an auto-reconnected session re-authenticates instead of
+    // being left at the server's login screen. Null when the character has no stored credentials.
+    private readonly Func<ValueTask<string?>>? _autoLoginProvider;
+    private ConnectionState _lastState = ConnectionState.Disconnected;
+
     // LineReceived fires off the network read thread while Blazor enumerates Scrollback on the
     // render thread — appending mid-enumeration throws "Collection was modified" and kills the UI.
     // _scrollbackLock guards every read and write of _scrollback; the Scrollback getter hands out an
@@ -41,9 +47,11 @@ public Session(
         ITriggerEngine? triggerEngine = null,
         IReadOnlyList<TriggerRule>? triggerRules = null,
         INotifier? notifier = null,
-        ISessionHistory? history = null)
+        ISessionHistory? history = null,
+        Func<ValueTask<string?>>? autoLoginProvider = null)
     {
         _connection = connection;
+        _autoLoginProvider = autoLoginProvider;
         CharacterName = characterName;
         WorldName = worldName;
         WorldId = worldId;
@@ -198,7 +206,38 @@ private async void OnLineReceived(string raw)
         }
     }
 
-    private void OnStateChanged(ConnectionState state) => StateChanged?.Invoke(state);
+    private void OnStateChanged(ConnectionState state)
+    {
+        var previous = _lastState;
+        _lastState = state;
+        StateChanged?.Invoke(state);
+
+        // On every transition into Connected — the initial connect AND each automatic reconnect —
+        // re-send the stored auto-login, so a dropped-and-reconnected session lands logged in
+        // instead of stranded at the server's login screen.
+        if (state == ConnectionState.Connected
+            && previous != ConnectionState.Connected
+            && _autoLoginProvider is not null)
+        {
+            _ = SendAutoLoginAsync();
+        }
+    }
+
+    private async Task SendAutoLoginAsync()
+    {
+        try
+        {
+            var command = await _autoLoginProvider!().ConfigureAwait(false);
+            if (!string.IsNullOrWhiteSpace(command))
+            {
+                await SendAsync(command).ConfigureAwait(false);
+            }
+        }
+        catch
+        {
+            // Best-effort: a failed auto-login just leaves the user at the login screen to retry.
+        }
+    }
 
     private void OnGmcpReceived(GmcpMessage msg)
     {

src/SharpClient.Core/Sessions/TelnetSessionLauncher.cs

@@ -50,6 +50,14 @@ public async Task<ISession> LaunchAsync(
         var aliasRules = MergeAliases(world.Aliases, character.Aliases);
         var triggerRules = MergeTriggers(world.Triggers, character.Triggers);
 
+        // Resolve the character's stored connect string on demand. The Session invokes this on the
+        // initial connect AND on every automatic reconnect, so a dropped session re-authenticates
+        // itself instead of being left at the server's login screen. The secret is fetched from the
+        // store each time rather than held in the Session.
+        Func<ValueTask<string?>>? autoLoginProvider = character.ConnectSecretKey is { } key
+            ? async () => await _secrets.GetAsync(key)
+            : null;
+
         var session = new Session(
             connection,
             character.Name,
@@ -61,27 +69,11 @@ public async Task<ISession> LaunchAsync(
             _triggerEngine,
             triggerRules,
             _notifier,
-            _history);
+            _history,
+            autoLoginProvider);
 
         await session.ConnectAsync(world.Host, world.Port, cancellationToken);
 
-        try
-        {
-            if (character.ConnectSecretKey is { } key)
-            {
-                var secret = await _secrets.GetAsync(key);
-                if (!string.IsNullOrWhiteSpace(secret))
-                {
-                    await session.SendAsync(secret);
-                }
-            }
-        }
-        catch
-        {
-            await session.DisposeAsync();
-            throw;
-        }
-
         return session;
     }
 

tests/SharpClient.Tests/Sessions/SessionStateTests.cs

@@ -33,6 +33,37 @@ public async Task SessionParsesLinesFromAnyConnection()
         await Assert.That(session.Scrollback[0].Segments[0].Text).IsEqualTo("plain");
     }
 
+    [Test]
+    public async Task SessionSendsAutoLoginOnConnectAndReconnect()
+    {
+        var fake = new FakeTelnetConnection();
+        await using var session = new Session(
+            fake, autoLoginProvider: () => ValueTask.FromResult<string?>("connect Foo secret"));
+
+        await session.ConnectAsync("host", 1);        // fake raises Connected
+        await Task.Delay(50);
+        // Simulate an unexpected drop + automatic reconnect.
+        fake.RaiseState(ConnectionState.Reconnecting);
+        fake.RaiseState(ConnectionState.Connected);
+        await Task.Delay(50);
+
+        // Login is re-sent on the reconnect, not just the initial connect.
+        var expected = new[] { "connect Foo secret", "connect Foo secret" };
+        await Assert.That(fake.Sent).IsEquivalentTo(expected);
+    }
+
+    [Test]
+    public async Task SessionWithoutAutoLoginSendsNothingOnConnect()
+    {
+        var fake = new FakeTelnetConnection();
+        await using var session = new Session(fake);
+
+        await session.ConnectAsync("host", 1);
+        await Task.Delay(50);
+
+        await Assert.That(fake.Sent).IsEmpty();
+    }
+
     [Test]
     public async Task ReconnectingAndErrorAreDistinctStates()
     {