feat(auth): restore the Telegram session automatically on startup

After a container restart the WTelegram client was created but the saved
session was only loaded when someone opened the web UI (Index.razor ->
checkAuth), so API/WebDAV requests failed with not_logged_in until then.

- TelegramService.TryRestoreSessionAsync(): non-interactive restore of a
  previously authorized session (client.UserId != 0), attempted once per
  process and shared by concurrent callers to avoid triggering new
  verification codes on a revoked session.
- TelegramSessionRestoreService (IHostedService): kicks the restore in the
  background on startup; OnUserLoggedIn then drives TaskResumeService as
  with the interactive login.
- RequireTelegramSession: when no session is active, awaits the automatic
  restore before answering 401, so the first API call after a restart
  succeeds even if it arrives before the startup restore finishes.

If there is no previous session nothing changes: interactive login through
the web UI (or /api/v1/auth) is still required.

Author: mateof

TelegramDownloader/Controllers/Api/V1/RequireTelegramSessionAttribute.cs

@@ -40,6 +40,22 @@ public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionE
                 loggedIn = false;
             }
 
+            if (!loggedIn)
+            {
+                // After a restart the session file may hold a valid session
+                // that nobody has loaded yet (it is normally loaded when the
+                // web UI is opened). Try the automatic restore before failing;
+                // concurrent requests share the same single attempt.
+                try
+                {
+                    loggedIn = await telegram.TryRestoreSessionAsync();
+                }
+                catch
+                {
+                    loggedIn = false;
+                }
+            }
+
             if (!loggedIn)
             {
                 context.Result = new ObjectResult(ApiResult.Fail(

TelegramDownloader/Data/ITelegramService.cs

@@ -11,6 +11,7 @@ public interface ITelegramService
         bool IsConfigured { get; }
         void InitializeClient();
         Task<string> checkAuth(string number, bool isPhone = false);
+        Task<bool> TryRestoreSessionAsync();
         Task<User> GetUser();
         bool checkChannelExist(string id);
         bool checkUserLogin();

TelegramDownloader/Data/TelegramService.cs

@@ -794,6 +794,52 @@ public async Task sendVerificationCode(string vc)
             await DoLogin(vc);
         }
 
+        // Single automatic restore attempt per process, shared by every caller
+        // (startup service and concurrent API requests await the same task). A
+        // failed attempt is NOT retried automatically: retrying checkAuth with
+        // a saved phone on a revoked session would trigger a new verification
+        // code on every call - the interactive (web) login is required then.
+        private static Task<bool> autoRestoreTask = null;
+        private static readonly object autoRestoreLock = new object();
+
+        public Task<bool> TryRestoreSessionAsync()
+        {
+            if (client == null)
+                return Task.FromResult(false);
+            if (client.User != null)
+                return Task.FromResult(true);
+            // UserId == 0 means the session file holds no authorized user:
+            // there is nothing to restore, interactive login is required.
+            if (client.UserId == 0)
+                return Task.FromResult(false);
+            lock (autoRestoreLock)
+            {
+                autoRestoreTask ??= RestoreSessionAsync();
+                return autoRestoreTask;
+            }
+        }
+
+        private async Task<bool> RestoreSessionAsync()
+        {
+            try
+            {
+                _logger.LogInformation("Restoring previous Telegram session automatically");
+                string result = await checkAuth(null);
+                if (result == "ok")
+                {
+                    _logger.LogInformation("Telegram session restored automatically");
+                    return true;
+                }
+                _logger.LogWarning("Automatic session restore not completed (result: {Result}) - interactive login required", result);
+                return false;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Automatic session restore failed - interactive login required");
+                return false;
+            }
+        }
+
         public bool checkUserLogin()
         {
 

TelegramDownloader/Program.cs

@@ -156,6 +156,12 @@
 builder.Services.AddSingleton<ITaskPersistenceService, TaskPersistenceService>();
 builder.Services.AddHostedService<TaskResumeService>();
 
+// Restore a previously authorized Telegram session on startup so the API and
+// WebDAV work after a restart without opening the web UI first. Registered
+// after TaskResumeService so its OnUserLoggedIn subscription exists when the
+// restore completes.
+builder.Services.AddHostedService<TelegramSessionRestoreService>();
+
 // Log query service - only if MongoDB is available
 builder.Services.AddSingleton<ILogQueryService>(sp =>
     new LogQueryService(mongoConnectionString ?? "mongodb://localhost:27017", sp.GetRequiredService<ILogger<LogQueryService>>()));

TelegramDownloader/Services/TelegramSessionRestoreService.cs

@@ -0,0 +1,51 @@
+using TelegramDownloader.Data;
+
+namespace TelegramDownloader.Services
+{
+    /// <summary>
+    /// Restores the previously authorized Telegram session on application
+    /// startup (e.g. after a container restart), so API clients and WebDAV
+    /// work without having to open the web UI first. When no previous session
+    /// exists this does nothing and the interactive (web) login is still
+    /// required.
+    /// </summary>
+    public class TelegramSessionRestoreService : IHostedService
+    {
+        private readonly IServiceProvider _serviceProvider;
+        private readonly ILogger<TelegramSessionRestoreService> _logger;
+
+        public TelegramSessionRestoreService(IServiceProvider serviceProvider, ILogger<TelegramSessionRestoreService> logger)
+        {
+            _serviceProvider = serviceProvider;
+            _logger = logger;
+        }
+
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            // Run in the background so a slow Telegram connection never delays
+            // the web server startup.
+            _ = Task.Run(async () =>
+            {
+                try
+                {
+                    var telegram = _serviceProvider.GetRequiredService<ITelegramService>();
+                    if (!telegram.IsConfigured)
+                    {
+                        _logger.LogInformation("Telegram not configured - skipping automatic session restore");
+                        return;
+                    }
+                    bool restored = await telegram.TryRestoreSessionAsync();
+                    if (!restored)
+                        _logger.LogInformation("No previous Telegram session to restore - login through the web UI or /api/v1/auth");
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogWarning(ex, "Automatic Telegram session restore failed on startup");
+                }
+            }, cancellationToken);
+            return Task.CompletedTask;
+        }
+
+        public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+    }
+}