[FIX] EventConsole batch fix

[REWORK] Changes saving client and channel info
[CHANGES]
2025-09-18 02:10:13 +02:00 · 2025-09-18 02:01:45 +02:00 · 2025-09-18 00:42:17 +02:00 · 2025-09-18 00:30:35 +02:00 · 2025-09-17 23:44:02 +02:00 · 2025-09-15 00:23:57 +02:00
76 changed files with 2616 additions and 1350 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -307,10 +307,6 @@ node_modules/
 *.dsw
 *.dsp

-# Visual Studio 6 technical files
-*.ncb
-*.aps
-
 # Visual Studio LightSwitch build output
 **/*.HTMLClient/GeneratedArtifacts
 **/*.DesktopClient/GeneratedArtifacts
@@ -404,14 +400,8 @@ FodyWeavers.xsd
 *.sln.iml
 .idea

-##
-## Visual studio for Mac
-##
-
-
 # globs
 Makefile.in
-*.userprefs
 *.usertasks
 config.make
 config.status
@@ -470,16 +460,12 @@ ehthumbs_vista.db
 # Recycle Bin used on file shares
 $RECYCLE.BIN/

-# Windows Installer files
-*.cab
-*.msi
-*.msix
-*.msm
-*.msp
-
 # Windows shortcuts
 *.lnk

 # Vim temporary swap files
 *.swp
-/Manager.App/Library/
+
+# Manager.App
+[Ll]ibrary/
+[Cc]ache/
--- a/Manager.App/Components/App.razor
+++ b/Manager.App/Components/App.razor
@@ -2,21 +2,23 @@
 <html lang="en">

 <head>
-    <title>Application</title>
+    <title>YouTube Manager server</title>
    <meta charset="utf-8"/>
    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
    <base href="/"/>
    <link rel="stylesheet" href="app.css"/>
+    <link href="Manager.App.styles.css" rel="stylesheet" />
    <link rel="icon" type="image/png" href="favicon.png"/>
    <link href="https://fonts.googleapis.com/css?family=Roboto:300,400,500,700&display=swap" rel="stylesheet"/>
    <link href="_content/MudBlazor/MudBlazor.min.css?v=@Metadata.Version" rel="stylesheet"/>
-    <HeadOutlet/>
 </head>

 <body>
 <Routes @rendermode="InteractiveServer"/>
 <script src="_framework/blazor.web.js"></script>
 <script src="_content/MudBlazor/MudBlazor.min.js?v=@Metadata.Version"></script>
+<script src="js/tz.js"></script>
+<script src="js/eventConsole.js"></script>
 </body>

 </html>
--- a/Manager.App/Components/Application/Dev/AuthenticationHasher.razor
+++ b/Manager.App/Components/Application/Dev/AuthenticationHasher.razor
@@ -0,0 +1,14 @@
+
+
+<MudText>SAPISID Hash generator</MudText>
+<MudStack Row Spacing="2">
+    <MudTextField HelperText="Datasync id" @bind-Value="@DatasyncId"/>
+    <MudTextField HelperText="Time" Mask="@(new PatternMask("0000000000"))" @bind-Value="@Time"/>
+    <MudTextField HelperText="SAPISID" @bind-Value="@SecureCookie"/>
+    <MudTextField HelperText="Origin" @bind-Value="@Origin"/>
+</MudStack>
+<MudTextField HelperText="Hash" ReadOnly @bind-Value="@OutputHash"/>
+<MudStack Row Spacing="2">
+    <MudButton OnClick="Hash">Generate</MudButton>
+    <MudButton OnClick="Clear">Clear</MudButton>
+</MudStack>
--- a/Manager.App/Components/Application/Dev/AuthenticationHasher.razor.cs
+++ b/Manager.App/Components/Application/Dev/AuthenticationHasher.razor.cs
@@ -0,0 +1,29 @@
+using Manager.YouTube.Util;
+using Microsoft.AspNetCore.Components;
+
+namespace Manager.App.Components.Application.Dev;
+
+public partial class AuthenticationHasher : ComponentBase
+{
+    private const string DefaultOrigin = "https://www.youtube.com";
+    public string DatasyncId { get; set; } = "";
+    public string Time { get; set; } = "";
+    public string SecureCookie { get; set; } = "";
+    public string Origin { get; set; } = DefaultOrigin;
+
+    public string OutputHash { get; set; } = "";
+
+    private void Clear()
+    {
+        DatasyncId = "";
+        Time = "";
+        SecureCookie = "";
+        Origin = DefaultOrigin;
+        OutputHash = "";
+    }
+
+    private void Hash()
+    {
+        OutputHash = AuthenticationUtilities.GetSapisidHash(DatasyncId, SecureCookie, Origin, Time);
+    }
+}
--- a/Manager.App/Components/Application/System/EventConsole.razor
+++ b/Manager.App/Components/Application/System/EventConsole.razor
@@ -0,0 +1,21 @@
+@inject IJSRuntime JsRuntime
+@implements IDisposable
+
+<MudPaper Elevation="Elevation" Class="@Class" Style="@Style">
+    <MudStack Class="ml-2 mb-2" Spacing="2" Row>
+        <MudStack Spacing="1">
+            <MudText Typo="Typo.h5">Live service events</MudText>
+            <MudText Typo="Typo.caption">@($"{_serviceEvents.Count} events")</MudText>
+        </MudStack>
+        <MudSwitch @bind-Value="@_autoScroll">Auto-scroll</MudSwitch>
+    </MudStack>
+    <div @ref="@_consoleContainer" class="console-container" @onwheel="OnUserScroll">
+        <Virtualize @ref="_virtualize" TItem="ServiceEvent" ItemsProvider="VirtualizedItemsProvider" Context="serviceEvent">
+            <div class="log-line">
+                @TimeZoneInfo.ConvertTime(serviceEvent.DateUtc, _timeZone)&nbsp;
+                <span class="log-severity @GetLogClass(serviceEvent)">@serviceEvent.Severity</span>&nbsp;[<span style="color: #1565c0">@serviceEvent.Source</span>]&nbsp;
+                <span style="color: snow">@serviceEvent.Message</span>
+            </div>
+        </Virtualize>
+    </div>
+</MudPaper>
--- a/Manager.App/Components/Application/System/EventConsole.razor.cs
+++ b/Manager.App/Components/Application/System/EventConsole.razor.cs
@@ -0,0 +1,165 @@
+using DotBased.Logging;
+using Manager.App.Services;
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Web;
+using Microsoft.AspNetCore.Components.Web.Virtualization;
+using Microsoft.JSInterop;
+
+namespace Manager.App.Components.Application.System;
+
+public partial class EventConsole : ComponentBase
+{
+    private const int BatchDelayMs = 2000;
+    private List<ServiceEvent> _serviceEvents = [];
+    private readonly List<ServiceEvent> _batchBuffer = [];
+    private readonly SemaphoreSlim _batchLock = new(1, 1);
+    private ElementReference _consoleContainer;
+    private bool _autoScroll = true;
+    private CancellationTokenSource _cts = new();
+    private TimeZoneInfo _timeZone = TimeZoneInfo.Local;
+    private Virtualize<ServiceEvent>? _virtualize;
+
+    [Parameter]
+    public List<ServiceEvent> InitialEvents { get; set; } = [];
+    [Parameter]
+    public IAsyncEnumerable<ServiceEvent>? AsyncEnumerable { get; set; }
+
+    [Parameter]
+    public int Elevation { get; set; }
+    [Parameter]
+    public string? Class { get; set; }
+    [Parameter]
+    public string? Style { get; set; }
+
+    protected override async Task OnInitializedAsync()
+    {
+        _serviceEvents.AddRange(InitialEvents);
+        var jsTimeZone = await JsRuntime.InvokeAsync<string>("getUserTimeZone");
+        if (!string.IsNullOrEmpty(jsTimeZone))
+        {
+            _timeZone = TimeZoneInfo.FindSystemTimeZoneById(jsTimeZone);
+        }
+        _ = Task.Run(() => ReadEventStreamsAsync(_cts.Token));
+    }
+
+    private async Task ReadEventStreamsAsync(CancellationToken token)
+    {
+        if (AsyncEnumerable == null)
+        {
+            return;
+        }
+        
+        await foreach (var serviceEvent in AsyncEnumerable.WithCancellation(token))
+        {
+            await _batchLock.WaitAsync(token);
+            try
+            {
+                _batchBuffer.Add(serviceEvent);
+            }
+            finally
+            {
+                _batchLock.Release();
+            }
+
+            _ = BatchUpdateUi();
+        }
+    }
+    
+    private string GetLogClass(ServiceEvent serviceEvent) =>
+        serviceEvent.Severity switch
+        {
+            LogSeverity.Info => "log-info",
+            LogSeverity.Warning => "log-warning",
+            LogSeverity.Error => "log-error",
+            LogSeverity.Debug => "log-debug",
+            LogSeverity.Trace => "log-trace",
+            LogSeverity.Fatal => "log-fatal",
+            LogSeverity.Verbose => "log-error",
+            _ => "log-info"
+        };
+    
+    private DateTime _lastBatchUpdate = DateTime.MinValue;
+    private bool _updateScheduled;
+
+    private async Task BatchUpdateUi()
+    {
+        if (_updateScheduled) return;
+        _updateScheduled = true;
+
+        while (!_cts.Token.IsCancellationRequested)
+        {
+            var elapsed = (DateTime.UtcNow - _lastBatchUpdate).TotalMilliseconds;
+            if (elapsed < BatchDelayMs)
+            {
+                await Task.Delay(BatchDelayMs - (int)elapsed, _cts.Token);
+            }
+
+            List<ServiceEvent> batch;
+            await _batchLock.WaitAsync();
+            try
+            {
+                if (_batchBuffer.Count == 0) continue;
+                batch = new List<ServiceEvent>(_batchBuffer);
+                _batchBuffer.Clear();
+            }
+            finally
+            {
+                _batchLock.Release();
+            }
+
+            foreach (var serviceEvent in batch.Where(serviceEvent => !_serviceEvents.Contains(serviceEvent)))
+            {
+                _serviceEvents.Add(serviceEvent);
+            }
+            
+            _lastBatchUpdate = DateTime.UtcNow;
+            
+            if (_virtualize != null)
+            {
+                await _virtualize.RefreshDataAsync();
+            }
+            
+            if (_autoScroll)
+            {
+                await JsRuntime.InvokeVoidAsync("scrollToBottom", _consoleContainer);
+            }
+            
+            await InvokeAsync(StateHasChanged);
+
+            _updateScheduled = false;
+            break;
+        }
+    }
+    
+    private void OnUserScroll(WheelEventArgs e)
+    {
+        _ = UpdateAutoScroll();
+    }
+    
+    private async Task UpdateAutoScroll()
+    {
+        if (_consoleContainer.Context != null)
+        {
+            var scrollInfo = await JsRuntime.InvokeAsync<ScrollInfo>("getScrollInfo", _consoleContainer);
+            _autoScroll = scrollInfo.ScrollTop + scrollInfo.ClientHeight >= scrollInfo.ScrollHeight - 20;
+        }
+    }
+    
+    private ValueTask<ItemsProviderResult<ServiceEvent>> VirtualizedItemsProvider(ItemsProviderRequest request)
+    {
+        var items = _serviceEvents.Skip(request.StartIndex).Take(request.Count);
+        return ValueTask.FromResult(new ItemsProviderResult<ServiceEvent>(items, _serviceEvents.Count));
+    }
+    
+    public void Dispose()
+    {
+        _batchLock.Dispose();
+    }
+    
+    private class ScrollInfo
+    {
+        public double ScrollTop { get; set; }
+        public double ScrollHeight { get; set; }
+        public double ClientHeight { get; set; }
+    }
+}
--- a/Manager.App/Components/Application/System/EventConsole.razor.css
+++ b/Manager.App/Components/Application/System/EventConsole.razor.css
@@ -0,0 +1,51 @@
+.console-container {
+    background-color: #1e1e1e;
+    color: #9c9898;
+    padding: 10px;
+    border-radius: 8px;
+    flex: 1;
+    overflow-y: auto;
+    font-family: monospace;
+}
+
+.log-severity{
+    display: inline-block;
+    width: 8ch;
+    text-align: left;
+    font-weight: bold;
+}
+
+.log-line {
+    display: flex;
+    justify-content: start;
+    align-items: center;
+    white-space: nowrap;
+}
+
+.log-info {
+    color: #3f6b81;
+}
+
+.log-warning {
+    color: #f8f802;
+}
+
+.log-error {
+    color: #f44747;
+}
+
+.log-debug {
+    color: #e110ff;
+}
+
+.log-trace {
+    color: #535353;
+}
+
+.log-fatal {
+    color: #af1e1e;
+}
+
+.log-verbose {
+    color: #8085ff;
+}
--- a/Manager.App/Components/Dialogs/AccountDialog.razor
+++ b/Manager.App/Components/Dialogs/AccountDialog.razor
@@ -0,0 +1,197 @@
+@using Manager.App.Services.System
+@inject ISnackbar SnackbarService
+@inject CacheService Cache
+
+<ForcedLoadingOverlay Visible="_isLoading"/>
+
+@{
+    var client = ClientChannel?.YouTubeClient;
+    var clientState = client?.State;
+    var channel = ClientChannel?.Channel;
+    var avatar = channel?.AvatarImages.FirstOrDefault();
+    var banner = channel?.BannerImages.FirstOrDefault();
+}
+<MudDialog>
+    <TitleContent>
+        <MudText Typo="Typo.h6">Add new account</MudText>
+    </TitleContent>
+    <DialogContent>
+        @switch (_steps)
+        {
+            case AccountImportSteps.Authenticate:
+                <MudStack Spacing="2">
+                    <MudPaper Elevation="0" Outlined Class="pa-2">
+                        <MudTextField @bind-Value="@DefaultUserAgent" Required Label="User agent"
+                                      HelperText="Use an WEB user agent."/>
+                    </MudPaper>
+
+                    <MudStack Row Spacing="2" Style="height: 100%">
+                        <MudPaper Elevation="0" Outlined Class="pa-2" Style="width: 50%;">
+                            <MudText>Import cookies</MudText>
+                            <MudText Typo="Typo.caption">@($"{ImportCookies.Count} cookie(s) imported")</MudText>
+                            <MudForm @bind-IsValid="@_cookieImportTextValid">
+                                <MudTextField @bind-Value="@_cookieDomain" Immediate Required Label="Domain"
+                                              RequiredError="Domain is required."/>
+                                <MudTextField Class="my-2" Lines="4" AutoGrow @bind-Value="@_cookieText" Immediate
+                                              Required Label="Cookies" Variant="Variant.Outlined"
+                                              Placeholder="EXAMPLE: Cookie1=Value1; Cookie2=Value2;"
+                                              Validation="@(new Func<string, string?>(ValidateCookieText))"/>
+                                <MudButton Variant="Variant.Outlined" Disabled="@(!_cookieImportTextValid)"
+                                           OnClick="ParseCookies">Import
+                                </MudButton>
+                            </MudForm>
+                        </MudPaper>
+
+                        <MudDataGrid Items="ImportCookies" Dense Elevation="0" Outlined Style="width: 50%;">
+                            <Header>
+                                <MudStack Class="ma-2">
+                                    <MudText>Cookies</MudText>
+                                </MudStack>
+                            </Header>
+                            <Columns>
+                                <TemplateColumn Title="Name">
+                                    <CellTemplate>
+                                        <MudTextField Variant="Variant.Text" @bind-Value="@context.Item.Name"
+                                                      Immediate/>
+                                    </CellTemplate>
+                                </TemplateColumn>
+                                <TemplateColumn Title="Domain">
+                                    <CellTemplate>
+                                        <MudTextField Variant="Variant.Text" @bind-Value="@context.Item.Domain"
+                                                      Immediate/>
+                                    </CellTemplate>
+                                </TemplateColumn>
+                                <TemplateColumn Title="Value">
+                                    <CellTemplate>
+                                        <MudTextField Variant="Variant.Text" @bind-Value="@context.Item.Value"
+                                                      Immediate/>
+                                    </CellTemplate>
+                                </TemplateColumn>
+                            </Columns>
+                        </MudDataGrid>
+                    </MudStack>
+                </MudStack>
+                break;
+            case AccountImportSteps.Validate:
+                <MudStack Spacing="3">
+                    <MudPaper Elevation="0">
+                        @if (banner != null)
+                        {
+                            <MudImage Src="@Cache.CreateCacheUrl(banner.Url)" Height="250" Style="width: 100%;"/>
+                        }
+                        else
+                        {
+                            <div Class="account-banner" Style="height: 250px; width: 100%;"></div>
+                        }
+                        <MudStack Row Spacing="3" Class="px-4">
+                            @if (avatar != null)
+                            {
+                                <MudImage Src="@Cache.CreateCacheUrl(avatar.Url)" Class="mt-n5" Height="100" Width="100"/>
+                            }
+                            else
+                            {
+                                <div Class="avatar-pattern mt-n6" Style="height: 100px; width: 100px;"></div>
+                            }
+                            <MudStack Spacing="0">
+                                <MudText Typo="Typo.h5">@(channel?.ChannelName ?? client?.Id)</MudText>
+                                <MudText Typo="Typo.caption">@(string.IsNullOrWhiteSpace(channel?.Description) ? "No description!" : channel.Description)</MudText>
+                            </MudStack>
+                        </MudStack>
+                    </MudPaper>
+                    
+                    <MudSimpleTable Bordered Dense Elevation="0" Outlined Square Hover>
+                        <tbody>
+                        <tr>
+                            <td>Account id:</td>
+                            <td>@client?.Id</td>
+                        </tr>
+                        <tr>
+                            <td>Account name:</td>
+                            <td>@channel?.ChannelName</td>
+                        </tr>
+                        <tr>
+                            <td>Account handle:</td>
+                            <td>@channel?.Handle</td>
+                        </tr>
+                        <tr>
+                            <td>Logged in:</td>
+                            <td style="@($"color: {(clientState?.LoggedIn ?? false ? "green" : "red")}")">@clientState?.LoggedIn</td>
+                        </tr>
+                        <tr>
+                            <td>YouTube Premium:</td>
+                            <td style="@($"color: {(clientState?.IsPremiumUser ?? false ? "green" : "red")}")">@clientState?.IsPremiumUser</td>
+                        </tr>
+
+                        <tr>
+                            <td>User agent:</td>
+                            <td>@client?.UserAgent</td>
+                        </tr>
+                        <tr>
+                            <td>InnerTube client:</td>
+                            <td>@clientState?.InnerTubeClient</td>
+                        </tr>
+                        <tr>
+                            <td>InnerTube client version:</td>
+                            <td>@clientState?.InnerTubeClientVersion</td>
+                        </tr>
+                        <tr>
+                            <td>InnerTube API key:</td>
+                            <td>@clientState?.InnertubeApiKey</td>
+                        </tr>
+                        <tr>
+                            <td>Language:</td>
+                            <td>@clientState?.InnerTubeContext?.InnerTubeClient?.HLanguage</td>
+                        </tr>
+                        </tbody>
+                    </MudSimpleTable>
+                </MudStack>
+                break;
+        }
+    </DialogContent>
+    <DialogActions>
+        <MudStack Spacing="2" Row>
+            <MudButton Color="Color.Error" OnClick="() => MudDialog?.Cancel()" Variant="Variant.Outlined">Cancel
+            </MudButton>
+            <MudButton Color="Color.Info" OnClick="ClearPreparedClient" Variant="Variant.Outlined">Reset</MudButton>
+            <MudButton Color="Color.Primary" OnClick="OnNextStep" Disabled="@(!CanContinue())" Variant="Variant.Outlined">@(_steps == AccountImportSteps.Validate ? "Save" : "Next")</MudButton>
+        </MudStack>
+    </DialogActions>
+</MudDialog>
+
+<style>
+    .account-banner {
+        width: 100%;
+        height: 180px;
+        display: flex;
+        align-items: flex-end;
+        padding: 1rem;
+        border-radius: 12px;
+
+        /* Pattern background */
+        background: repeating-linear-gradient(
+            135deg,
+            #1976d2,       /* MudBlazor Primary */
+            #1976d2 20px,
+            #1565c0 20px,
+            #1565c0 40px
+        );
+        color: white;
+    }
+
+    .avatar-pattern {
+        width: 80px;
+        height: 80px;
+        font-weight: bold;
+        font-size: 1.5rem;
+        color: white;
+
+        /* Patterned background */
+        background: repeating-linear-gradient(
+            45deg,
+            #1976d2,
+            #1976d2 10px,
+            #1565c0 10px,
+            #1565c0 20px
+        );
+    }
+</style>
--- a/Manager.App/Components/Dialogs/AccountDialog.razor.cs
+++ b/Manager.App/Components/Dialogs/AccountDialog.razor.cs
@@ -0,0 +1,174 @@
+using System.Net;
+using Manager.App.Models.Library;
+using Manager.YouTube;
+using Microsoft.AspNetCore.Components;
+using MudBlazor;
+
+namespace Manager.App.Components.Dialogs
+{
+    public partial class AccountDialog : ComponentBase
+    {
+        [CascadingParameter] private IMudDialogInstance? MudDialog { get; set; }
+        [Parameter] public string DefaultUserAgent { get; set; } = "";
+        private ClientChannel? ClientChannel { get; set; }
+        private CookieCollection ImportCookies { get; set; } = [];
+        private bool _isLoading;
+        private AccountImportSteps _steps = AccountImportSteps.Authenticate;
+
+        private bool _cookieImportTextValid;
+        private string _cookieText = "";
+        private string _cookieDomain = ".youtube.com";
+        
+        private bool CanSave()
+        {
+            return ClientChannel?.YouTubeClient?.State?.LoggedIn == true;
+        }
+
+        private bool CanContinue()
+        {
+            switch (_steps)
+            {
+                case AccountImportSteps.Authenticate:
+                    if (ImportCookies.Count != 0)
+                    {
+                        return true;
+                    }
+                    break;
+                case AccountImportSteps.Validate:
+                    if (ClientChannel?.YouTubeClient?.State?.LoggedIn == true)
+                    {
+                        return true;
+                    }
+                    break;
+            }
+            return false;
+        }
+
+        private async Task OnNextStep()
+        {
+            switch (_steps)
+            {
+                case AccountImportSteps.Authenticate:
+                    if (CanContinue())
+                    {
+                        _steps = AccountImportSteps.Validate;
+                        await BuildClient();
+                        await InvokeAsync(StateHasChanged);
+                        return;
+                    }
+                    SnackbarService.Add("Cannot continue!", Severity.Warning);
+                    break;
+                case AccountImportSteps.Validate:
+                    if (CanSave())
+                    {
+                        MudDialog?.Close(DialogResult.Ok(ClientChannel));
+                        await InvokeAsync(StateHasChanged);
+                        return;
+                    }
+                    SnackbarService.Add("Cannot save!", Severity.Warning);
+                    break;
+            }
+            await InvokeAsync(StateHasChanged);
+        }
+
+        private void ParseCookies()
+        {
+            try
+            {
+                ImportCookies.Clear();
+                ImportCookies.Add(ParseCookieHeader(_cookieText, _cookieDomain));
+                _cookieText = string.Empty;
+            }
+            catch (Exception e)
+            {
+                SnackbarService.Add($"Parsing cookies failed: {e.Message}", Severity.Error);
+            }
+            StateHasChanged();
+        }
+
+        private void ClearPreparedClient()
+        {
+            ClientChannel?.YouTubeClient?.Dispose();
+            ClientChannel = null;
+            ImportCookies.Clear();
+            _steps = AccountImportSteps.Authenticate;
+            StateHasChanged();
+        }
+
+        private static string? ValidateCookieText(string text)
+        {
+            if (string.IsNullOrWhiteSpace(text))
+                return "Cookies are required";
+
+            var pairs = text.Split(';', StringSplitOptions.RemoveEmptyEntries);
+            foreach (var pair in pairs)
+            {
+                if (!pair.Contains('=')) return "Invalid.";
+                var key = pair[..pair.IndexOf('=')].Trim();
+                if (string.IsNullOrEmpty(key)) return "Invalid.";
+            }
+
+            return null;
+        }
+
+        public static CookieCollection ParseCookieHeader(string cookieHeader, string domain = "")
+        {
+            var collection = new CookieCollection();
+
+            if (string.IsNullOrWhiteSpace(cookieHeader))
+                return collection;
+
+            var cookies = cookieHeader.Split(';', StringSplitOptions.RemoveEmptyEntries);
+
+            foreach (var cookieStr in cookies)
+            {
+                var parts = cookieStr.Split('=', 2);
+                if (parts.Length != 2) continue;
+                
+                var name = parts[0].Trim();
+                var value = parts[1].Trim();
+
+                var cookie = new Cookie(name, value)
+                {
+                    Path = "/",
+                    Domain = domain
+                };
+                collection.Add(cookie);
+            }
+
+            return collection;
+        }
+        
+        private async Task BuildClient()
+        {
+            _isLoading = true;
+            ClientChannel = new ClientChannel();
+            var clientResult = await YouTubeClient.CreateAsync(ImportCookies, DefaultUserAgent);
+            if (clientResult.IsSuccess)
+            {
+                ClientChannel.YouTubeClient = clientResult.Value;
+            }
+
+            if (ClientChannel.YouTubeClient == null)
+            {
+                SnackbarService.Add("Failed to get client!", Severity.Error);
+                _isLoading = false;
+                return;
+            }
+
+            var accountResult = await ClientChannel.YouTubeClient.GetChannelByIdAsync(ClientChannel.YouTubeClient.Id);
+            if (accountResult.IsSuccess)
+            {
+                ClientChannel.Channel = accountResult.Value;
+            }
+            _isLoading = false;
+            await InvokeAsync(StateHasChanged);
+        }
+    }
+
+    public enum AccountImportSteps
+    {
+        Authenticate,
+        Validate
+    }
+}
--- a/Manager.App/Components/Layout/ApplicationLayout.razor
+++ b/Manager.App/Components/Layout/ApplicationLayout.razor
@@ -16,7 +16,7 @@
            </MudTooltip>
        }
    </MudAppBar>
-    <div style="margin: 20px">
+    <div style="display: flex; flex-direction: column; flex: 1; padding: 20px; min-height: 0;">
        @Body
    </div>
 </CascadingValue>
--- a/Manager.App/Components/Layout/BaseLayout.razor
+++ b/Manager.App/Components/Layout/BaseLayout.razor
@@ -7,7 +7,7 @@

 <CascadingValue Value="this">
    <MudLayout>
-        <MudMainContent>
+        <MudMainContent Style="display: flex; flex-direction: column; height: 100vh;">
            @Body
        </MudMainContent>
    </MudLayout>
--- a/Manager.App/Components/Layout/NavMenu.razor
+++ b/Manager.App/Components/Layout/NavMenu.razor
@@ -1,7 +1,9 @@

 <MudNavMenu>
-    <MudNavLink Href="/" Match="NavLinkMatch.Prefix">Home</MudNavLink>
-    <MudNavLink Href="/Accounts" Match="NavLinkMatch.All">Accounts</MudNavLink>
-    <MudNavLink Href="/Library" Match="NavLinkMatch.All">Library</MudNavLink>
-    <MudNavLink Href="/Playlists" Match="NavLinkMatch.All">Playlists</MudNavLink>
+    <MudNavLink Href="/" Icon="@Icons.Material.Filled.Home" Match="NavLinkMatch.All">Home</MudNavLink>
+    <MudNavLink Href="/Channels" Icon="@Icons.Material.Filled.SupervisorAccount" Match="NavLinkMatch.All">Channels</MudNavLink>
+    <MudNavLink Href="/Library" Icon="@Icons.Material.Filled.LocalLibrary" Match="NavLinkMatch.All">Library</MudNavLink>
+    <MudNavLink Href="/Playlists" Icon="@Icons.Material.Filled.ViewList" Match="NavLinkMatch.All">Playlists</MudNavLink>
+    <MudNavLink Href="/Development" Icon="@Icons.Material.Filled.DeveloperMode" Match="NavLinkMatch.All">Development</MudNavLink>
+    <MudNavLink Href="/Services" Icon="@Icons.Material.Filled.MiscellaneousServices" Match="NavLinkMatch.All">Services</MudNavLink>
 </MudNavMenu>
--- a/Manager.App/Components/Pages/Accounts.razor
+++ b/Manager.App/Components/Pages/Accounts.razor
@@ -1,4 +0,0 @@
-@page "/Accounts"
-
-<PageTitle>Accounts</PageTitle>
-
--- a/Manager.App/Components/Pages/Channels.razor
+++ b/Manager.App/Components/Pages/Channels.razor
@@ -0,0 +1,46 @@
+@page "/Channels"
+@using Manager.App.Models.Settings
+@using Manager.App.Services.System
+@using Microsoft.Extensions.Options
+
+@inject ILibraryService LibraryService
+@inject IDialogService DialogService
+@inject IOptions<LibrarySettings> LibraryOptions
+@inject ClientService ClientService
+@inject ISnackbar Snackbar
+
+<PageTitle>Channels</PageTitle>
+
+
+<MudStack Spacing="2">
+    <MudPaper Elevation="0" Outlined>
+        <MudStack Row Class="ma-2">
+            <MudButton IconSize="Size.Small" StartIcon="@Icons.Material.Filled.Add" Variant="Variant.Outlined" OnClick="OnAddAccountDialogAsync">Add account</MudButton>
+        </MudStack>
+    </MudPaper>
+    
+    <MudTable @ref="@_table" ServerData="ServerReload">
+        <ToolBarContent>
+            <MudText Typo="Typo.h6">Channels</MudText>
+        </ToolBarContent>
+        <HeaderContent>
+            <MudTh>Name</MudTh>
+            <MudTh>Channel id</MudTh>
+            <MudTh>Has login</MudTh>
+        </HeaderContent>
+        <RowTemplate>
+            <MudTd>@context.Name</MudTd>
+            <MudTd>@context.Id</MudTd>
+            <MudTd>@(context.ClientAccount != null)</MudTd>
+        </RowTemplate>
+        <NoRecordsContent>
+            <MudText>No channels found</MudText>
+        </NoRecordsContent>
+        <LoadingContent>
+            <MudText>Loading...</MudText>
+        </LoadingContent>
+        <PagerContent>
+            <MudTablePager/>
+        </PagerContent>
+    </MudTable>
+</MudStack>
--- a/Manager.App/Components/Pages/Channels.razor.cs
+++ b/Manager.App/Components/Pages/Channels.razor.cs
@@ -0,0 +1,67 @@
+using Manager.App.Components.Dialogs;
+using Manager.App.Models.Library;
+using Manager.Data.Entities.LibraryContext;
+using Microsoft.AspNetCore.Components;
+using MudBlazor;
+
+namespace Manager.App.Components.Pages;
+
+public partial class Channels : ComponentBase
+{
+    private readonly DialogOptions _dialogOptions = new() { BackdropClick = false, CloseButton = true, FullWidth = true, MaxWidth = MaxWidth.ExtraLarge };
+    private MudTable<ChannelEntity>? _table;
+    
+    private async Task<TableData<ChannelEntity>> ServerReload(TableState state, CancellationToken token)
+    {
+        var results = await LibraryService.GetChannelsAsync(state.PageSize, state.Page * state.PageSize, token);
+        return !results.IsSuccess ? new TableData<ChannelEntity>() : new TableData<ChannelEntity> { Items = results.Value, TotalItems = results.Total };
+    }
+    
+    private async Task OnAddAccountDialogAsync()
+    {
+        var libSettings = LibraryOptions.Value;
+        var parameters = new DialogParameters<AccountDialog> { { x => x.DefaultUserAgent, libSettings.DefaultUserAgent } };
+        var dialog = await DialogService.ShowAsync<AccountDialog>("Add account", parameters, _dialogOptions);
+        var result = await dialog.Result;
+
+        if (result == null || result.Canceled || result.Data == null)
+        {
+            return;
+        }
+        
+        var clientChannel = (ClientChannel)result.Data;
+        if (clientChannel?.YouTubeClient == null)
+        {
+            Snackbar.Add("No YouTube client received.", Severity.Error);
+            return;
+        }
+
+        var savedClientResult = await ClientService.SaveClientAsync(clientChannel.YouTubeClient);
+        if (savedClientResult.IsSuccess)
+        {
+            if (_table != null)
+            {
+                await _table.ReloadServerData();
+            }
+            Snackbar.Add($"Client {clientChannel.Channel?.Handle ?? clientChannel.YouTubeClient.Id} saved!", Severity.Success);
+            ClientService.AddClient(clientChannel.YouTubeClient);
+        }
+        else
+        {
+            Snackbar.Add($"Failed to store client: {savedClientResult.Error?.Description ?? "Unknown!"}", Severity.Error);
+        }
+
+        if (clientChannel.Channel == null)
+        {
+            Snackbar.Add("No channel information received!", Severity.Warning);
+        }
+        else
+        {
+            var saveChannelResult = await LibraryService.SaveChannelAsync(clientChannel.Channel);
+            if (!saveChannelResult.IsSuccess)
+            {
+                Snackbar.Add("Failed to save channel information", Severity.Warning);
+            }
+        }
+    }
+}
--- a/Manager.App/Components/Pages/Development.razor
+++ b/Manager.App/Components/Pages/Development.razor
@@ -0,0 +1,9 @@
+@page "/Development"
+@using Manager.App.Components.Application.Dev
+<PageTitle>Development page</PageTitle>
+
+<MudTabs Outlined Position="Position.Left" PanelClass="pa-4" ApplyEffectsToContainer Style="height: 100%">
+    <MudTabPanel Text="Authentication">
+        <AuthenticationHasher />
+    </MudTabPanel>
+</MudTabs>
--- a/Manager.App/Components/Pages/Development.razor.cs
+++ b/Manager.App/Components/Pages/Development.razor.cs
@@ -2,7 +2,7 @@ using Microsoft.AspNetCore.Components;

 namespace Manager.App.Components.Pages;

-public partial class Accounts : ComponentBase
+public partial class Development : ComponentBase
 {
    
 }
--- a/Manager.App/Components/Pages/Library.razor.cs
+++ b/Manager.App/Components/Pages/Library.razor.cs
@@ -1,9 +1,10 @@
 using Manager.App.Models.Library;
+using Microsoft.AspNetCore.Components;
 using MudBlazor;

 namespace Manager.App.Components.Pages;

-public partial class Library
+public partial class Library : ComponentBase
 {
    private LibraryInformation? _libraryInformation;
    private bool _loading;
--- a/Manager.App/Components/Pages/Services.razor
+++ b/Manager.App/Components/Pages/Services.razor
@@ -0,0 +1,42 @@
+@page "/Services"
+@using Manager.App.Services.System
+@using Manager.App.Components.Application.System
+@implements IDisposable
+
+@inject BackgroundServiceRegistry ServiceRegistry
+
+<PageTitle>Services</PageTitle>
+
+<MudDataGrid T="ExtendedBackgroundService" Items="@_backgroundServices" Filterable QuickFilter="@QuickFilter">
+    <ToolBarContent>
+        <MudText Typo="Typo.h6">Services</MudText>
+        <MudSpacer/>
+        <MudTextField T="string" @bind-Value="@_searchText" Immediate
+                      Placeholder="Search" Adornment="Adornment.Start"
+                      AdornmentIcon="@Icons.Material.Filled.Search" IconSize="Size.Medium"/>
+    </ToolBarContent>
+    <Columns>
+        <PropertyColumn Property="x => x.Name" Title="Service"/>
+        <PropertyColumn Property="x => x.Description" Title="Description"/>
+        <PropertyColumn Property="x => x.State" Title="Status"/>
+        <PropertyColumn Property="x => x.ExecuteInterval" Title="Execute interval"/>
+        <TemplateColumn>
+            <CellTemplate>
+                <MudStack Row Spacing="2">
+                    <MudButton Disabled="@(context.Item?.State == ServiceState.Paused)"
+                               OnClick="@(() => { context.Item?.Pause(); })" Variant="Variant.Outlined">Pause
+                    </MudButton>
+                    <MudButton Disabled="@(context.Item?.State == ServiceState.Running)"
+                               OnClick="@(() => { context.Item?.Resume(); })" Variant="Variant.Outlined">Resume
+                    </MudButton>
+                </MudStack>
+            </CellTemplate>
+        </TemplateColumn>
+    </Columns>
+    <PagerContent>
+        <MudDataGridPager T="ExtendedBackgroundService"/>
+    </PagerContent>
+</MudDataGrid>
+
+<EventConsole AsyncEnumerable="@GetEventAsyncEnumerable()" InitialEvents="@GetInitialEvents()"
+              Elevation="0" Class="mt-3" Style="flex: 1; display: flex; flex-direction: column; min-height: 350px;"/>
--- a/Manager.App/Components/Pages/Services.razor.cs
+++ b/Manager.App/Components/Pages/Services.razor.cs
@@ -0,0 +1,41 @@
+using Manager.App.Extensions;
+using Manager.App.Services;
+using Microsoft.AspNetCore.Components;
+
+namespace Manager.App.Components.Pages;
+
+public partial class Services : ComponentBase
+{
+    private string _searchText = "";
+    private List<ExtendedBackgroundService> _backgroundServices = [];
+    private readonly CancellationTokenSource _cts = new();
+
+    protected override void OnInitialized()
+    {
+        _backgroundServices = ServiceRegistry.GetServices();
+    }
+    
+    private Func<ExtendedBackgroundService, bool> QuickFilter
+        => x => string.IsNullOrWhiteSpace(_searchText) || $"{x.Name} {x.Description} {x.State} {x.ExecuteInterval}".Contains(_searchText);
+
+    private IAsyncEnumerable<ServiceEvent> GetEventAsyncEnumerable()
+    {
+        var asyncEnumerators = _backgroundServices.Select(x => x.ProgressEvents.GetStreamAsync());
+        return AsyncEnumerableExtensions.Merge(asyncEnumerators, CancellationToken.None);
+    }
+
+    private List<ServiceEvent> GetInitialEvents()
+    {
+        var totalToGet = 1000 / _backgroundServices.Count;
+        var initial = _backgroundServices
+            .SelectMany(x => x.ProgressEvents.Items.TakeLast(totalToGet))
+            .OrderBy(x => x.DateUtc);
+        return initial.ToList();
+    }
+
+    public void Dispose()
+    {
+        _cts.Cancel();
+        _cts.Dispose();
+    }
+}
--- a/Manager.App/Components/Routes.razor
+++ b/Manager.App/Components/Routes.razor
@@ -3,4 +3,5 @@
        <RouteView RouteData="routeData" DefaultLayout="typeof(Layout.MainLayout)"/>
        <FocusOnNavigate RouteData="routeData" Selector="h1"/>
    </Found>
-</Router>
+</Router>
+<HeadOutlet />
--- a/Manager.App/Components/_Imports.razor
+++ b/Manager.App/Components/_Imports.razor
@@ -1,6 +1,4 @@
-@using System.Net.Http
-@using System.Net.Http.Json
-@using Microsoft.AspNetCore.Components.Forms
+@using Microsoft.AspNetCore.Components.Forms
@using Microsoft.AspNetCore.Components.Routing
@using Microsoft.AspNetCore.Components.Web
@using static Microsoft.AspNetCore.Components.Web.RenderMode
--- a/Manager.App/Constants/LibraryConstants.cs
+++ b/Manager.App/Constants/LibraryConstants.cs
@@ -0,0 +1,18 @@
+namespace Manager.App.Constants;
+
+public static class LibraryConstants
+{
+    public static class Directories
+    {
+        public const string SubDirMedia = "Media";
+        public const string SubDirChannels = "Channels";
+    }
+    
+    public static class FileTypes
+    {
+        public const string ChannelAvatar = "channel/avatar";
+        public const string ChannelBanner = "channel/banner";
+        public const string VideoThumbnail = "video/thumbnail";
+        public const string VideoCaption = "video/caption";
+    }
+}
--- a/Manager.App/Controllers/CacheController.cs
+++ b/Manager.App/Controllers/CacheController.cs
@@ -0,0 +1,27 @@
+using Manager.App.Services.System;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Manager.App.Controllers;
+
+[ApiController]
+[Route("api/v1/[controller]")]
+public class CacheController(ILogger<CacheController> logger, CacheService cacheService) : ControllerBase
+{
+    [HttpGet]
+    public async Task<IActionResult> Cache([FromQuery(Name = "url")] string url, CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrWhiteSpace(url))
+        {
+            return BadRequest("No url given.");
+        }
+
+        var cacheResult = await cacheService.CacheFromUrl(url, cancellationToken);
+        if (!cacheResult.IsSuccess)
+        {
+            logger.LogError("Cache request failed. {ErrorMessage}", cacheResult.Error?.Description);
+            return StatusCode(500, cacheResult.Error?.Description);
+        }
+
+        return File(cacheResult.Value.Data, cacheResult.Value.ContentType ?? string.Empty, cacheResult.Value.OriginalFileName);
+    }
+}
--- a/Manager.App/DependencyInjection.cs
+++ b/Manager.App/DependencyInjection.cs
@@ -3,6 +3,7 @@ using DotBased.Logging.MEL;
 using DotBased.Logging.Serilog;
 using Manager.App.Models.Settings;
 using Manager.App.Services;
+using Manager.App.Services.System;
 using Manager.Data.Contexts;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Options;
@@ -23,7 +24,9 @@ public static class DependencyInjection
            logger.LogInformation("Setting library database to: {DbPath}", dbPath);
            options.UseSqlite($"Data Source={dbPath}");
        });
-
+        
+        builder.RegisterExtendedBackgroundServices();
+        
        builder.Services.AddScoped<ILibraryService, LibraryService>();
    }

@@ -83,4 +86,20 @@ public static class DependencyInjection
        builder.Logging.SetMinimumLevel(isDevelopment ? LogLevel.Trace : LogLevel.Information);
        builder.Logging.AddDotBasedLoggerProvider(LogService.Options);
    }
+
+    private static void RegisterExtendedBackgroundServices(this WebApplicationBuilder builder)
+    {
+        var assembly = typeof(Program).Assembly;
+
+        foreach (var exBgService in assembly.GetTypes()
+                     .Where(t => typeof(ExtendedBackgroundService).IsAssignableFrom(t) 
+                                 && t is { IsClass: true, IsAbstract: false }))
+        {
+            builder.Services.AddSingleton(exBgService);
+            builder.Services.AddSingleton(typeof(ExtendedBackgroundService), sp => (ExtendedBackgroundService)sp.GetRequiredService(exBgService));
+            builder.Services.AddSingleton<IHostedService>(sp => (IHostedService)sp.GetRequiredService(exBgService));
+        }
+        
+        builder.Services.AddSingleton<BackgroundServiceRegistry>();
+    }
 }
--- a/Manager.App/Extensions/AsyncEnumerableExtensions.cs
+++ b/Manager.App/Extensions/AsyncEnumerableExtensions.cs
@@ -0,0 +1,48 @@
+using System.Threading.Channels;
+
+namespace Manager.App.Extensions;
+
+public static class AsyncEnumerableExtensions
+{
+    public static async IAsyncEnumerable<T> Merge<T>(IEnumerable<IAsyncEnumerable<T>> sources, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default)
+    {
+        var channel = Channel.CreateUnbounded<T>( new UnboundedChannelOptions { SingleReader = true, SingleWriter = false });
+        
+        var writerTasks = sources.Select(source => Task.Run(async () =>
+        {
+            try
+            {
+                await foreach (var item in source.WithCancellation(cancellationToken))
+                {
+                    await channel.Writer.WriteAsync(item, cancellationToken);
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                
+            }
+            catch (Exception ex)
+            {
+                channel.Writer.TryComplete(ex);
+            }
+        }, cancellationToken)).ToArray();
+
+        _ = Task.Run(async () =>
+        {
+            try
+            {
+                await Task.WhenAll(writerTasks);
+                channel.Writer.TryComplete();
+            }
+            catch
+            {
+                channel.Writer.TryComplete();
+            }
+        }, cancellationToken);
+
+        await foreach (var item in channel.Reader.ReadAllAsync(cancellationToken))
+        {
+            yield return item;
+        }
+    }
+}
--- a/Manager.App/Manager.App.csproj
+++ b/Manager.App/Manager.App.csproj
@@ -22,6 +22,7 @@
    <ItemGroup>
      <_ContentIncludedByDefault Remove="wwwroot\bootstrap\bootstrap.min.css" />
      <_ContentIncludedByDefault Remove="wwwroot\bootstrap\bootstrap.min.css.map" />
+      <_ContentIncludedByDefault Remove="wwwroot\js\console.js" />
    </ItemGroup>

    <ItemGroup>
@@ -31,6 +32,7 @@
    </ItemGroup>

    <ItemGroup>
+      <Folder Include="cache\" />
      <Folder Include="Library\" />
      <Folder Include="Logs\Debug\" />
    </ItemGroup>
--- a/Manager.App/Models/System/ListResult.cs
+++ b/Manager.App/Models/System/ListResult.cs
@@ -0,0 +1,30 @@
+using DotBased.Monads;
+
+namespace Manager.App.Models.System;
+
+public class ListResult<TResult> : Result<List<TResult>>
+{
+    protected ListResult(List<TResult> result, int total) : base(result)
+    {
+        Total = total;
+    }
+
+    protected ListResult(Exception exception) : base(exception)
+    {
+        Total = 0;
+    }
+
+    protected ListResult(ResultError error) : base(error)
+    {
+        Total = 0;
+    }
+    
+    public int Total { get; set; }
+    
+    public static implicit operator ListResult<TResult>(ResultError error) => new(error);
+    public static implicit operator ListResult<TResult>(Exception exception) => new(exception);
+    public static implicit operator ListResult<TResult>(List<TResult> result) => new(result, 0);
+    public static implicit operator ListResult<TResult>(ListResultReturn<TResult> result) => new(result.List, result.Total);
+}
+
+public record ListResultReturn<TResult>(List<TResult> List, int Total);
--- a/Manager.App/Program.cs
+++ b/Manager.App/Program.cs
@@ -8,6 +8,9 @@ var builder = WebApplication.CreateBuilder(args);
 builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();

+AppContext.SetSwitch("System.Net.Http.EnableActivityPropagation", false);
+
+builder.Services.AddControllers();

 /* Manager */
 builder.SetupLogging();
@@ -31,6 +34,7 @@ app.UseHttpsRedirection();

 app.UseStaticFiles();
 app.UseAntiforgery();
+app.MapControllers();

 app.MapRazorComponents<App>()
    .AddInteractiveServerRenderMode();
--- a/Manager.App/Services/CircularBuffer.cs
+++ b/Manager.App/Services/CircularBuffer.cs
@@ -0,0 +1,64 @@
+using System.Threading.Channels;
+
+namespace Manager.App.Services;
+
+public class CircularBuffer <T>
+{
+    private readonly T[] _buffer;
+    private readonly Channel<T> _channel;
+    private readonly object _lock = new();
+
+    public int Capacity { get; }
+    public int Head { get; private set; }
+    public int Count { get; private set; }
+
+
+    public CircularBuffer(int capacity)
+    {
+        if (capacity <= 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(capacity));
+        }
+        
+        Capacity = capacity;
+        _buffer = new T[Capacity];
+        _channel = Channel.CreateBounded<T>(new BoundedChannelOptions(Capacity)
+        {
+            SingleReader = false,
+            SingleWriter = false,
+            FullMode = BoundedChannelFullMode.DropOldest
+        });
+    }
+
+    public void Add(T item)
+    {
+        lock (_lock)
+        {
+            _buffer[Head] = item;
+            Head = (Head + 1) % _buffer.Length;
+
+            if (Count < _buffer.Length)
+            {
+                Count++;
+            }
+        }
+
+        _channel.Writer.TryWrite(item);
+    }
+
+    public IEnumerable<T> Items
+    {
+        get
+        {
+            for (var i = 0; i < Count; i++)
+            {
+                lock (_lock)
+                {
+                    yield return _buffer[(Head - Count + i + _buffer.Length) % _buffer.Length];
+                }
+            }
+        }
+    }
+
+    public IAsyncEnumerable<T> GetStreamAsync() => _channel.Reader.ReadAllAsync();
+}
--- a/Manager.App/Services/ExtendedBackgroundService.cs
+++ b/Manager.App/Services/ExtendedBackgroundService.cs
@@ -0,0 +1,97 @@
+using DotBased.Logging;
+using ILogger = Microsoft.Extensions.Logging.ILogger;
+
+namespace Manager.App.Services;
+
+public abstract class ExtendedBackgroundService(string name, string description, ILogger logger, TimeSpan? executeInterval = null)
+    : BackgroundService
+{
+    private TaskCompletionSource _resumeSignal = new(TaskCreationOptions.RunContinuationsAsynchronously);
+    public ServiceState State { get; private set; } = ServiceState.Stopped;
+    public CircularBuffer<ServiceEvent> ProgressEvents { get; } = new(500);
+    public string Name { get; } = name;
+    public string Description { get; set; } = description;
+    public TimeSpan ExecuteInterval { get; set; } = executeInterval ?? TimeSpan.FromMinutes(1);
+
+    protected sealed override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        State = ServiceState.Running;
+        logger.LogInformation("Initializing background service: {ServiceName}", Name);
+        await InitializeAsync(stoppingToken);
+        
+        try
+        {
+            logger.LogInformation("Running background service: {ServiceName}", Name);
+            while (!stoppingToken.IsCancellationRequested)
+            {
+                if (State == ServiceState.Paused)
+                {
+                    _resumeSignal = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+                    await _resumeSignal.Task.WaitAsync(stoppingToken);
+                }
+
+                await ExecuteServiceAsync(stoppingToken);
+                
+                await Task.Delay(ExecuteInterval, stoppingToken);
+            }
+        }
+        catch (Exception e)
+        {
+            if (e is not OperationCanceledException)
+            {
+                State = ServiceState.Faulted;
+                logger.LogError(e,"Background service {ServiceName} faulted!", Name);
+                throw;
+            }
+            logger.LogInformation(e,"Service {ServiceName} received cancellation", Name);
+        }
+        finally
+        {
+            State = ServiceState.Stopped;
+        }
+    }
+
+    protected void LogEvent(string message, LogSeverity severity = LogSeverity.Info) => ProgressEvents.Add(new ServiceEvent(string.Intern(Name), message, DateTime.UtcNow, severity));
+
+    public void Pause()
+    {
+        if (State == ServiceState.Running)
+        {
+            State = ServiceState.Paused;
+            LogEvent("Service paused.");
+        }
+    }
+
+    public void Resume()
+    {
+        if (State == ServiceState.Paused)
+        {
+            State = ServiceState.Running;
+            _resumeSignal.TrySetResult();
+            LogEvent("Service resumed.");
+        }
+    }
+
+    protected abstract Task InitializeAsync(CancellationToken stoppingToken);
+    protected abstract Task ExecuteServiceAsync(CancellationToken stoppingToken);
+
+    public override bool Equals(object? obj)
+    {
+        return obj is ExtendedBackgroundService bgService && bgService.Name.Equals(Name, StringComparison.OrdinalIgnoreCase);
+    }
+
+    public override int GetHashCode()
+    {
+        return Name.GetHashCode();
+    }
+}
+
+public enum ServiceState
+{
+    Stopped,
+    Faulted,
+    Running,
+    Paused
+}
+
+public record struct ServiceEvent(string Source, string Message, DateTime DateUtc, LogSeverity Severity);
--- a/Manager.App/Services/ILibraryService.cs
+++ b/Manager.App/Services/ILibraryService.cs
@@ -1,9 +1,19 @@
 using DotBased.Monads;
 using Manager.App.Models.Library;
+using Manager.App.Models.System;
+using Manager.Data.Entities.LibraryContext;
+using Manager.YouTube.Models.Innertube;

 namespace Manager.App.Services;

 public interface ILibraryService
 {
+    public Task<Result> FetchChannelImagesAsync(InnertubeChannel innertubeChannel);
+    public Task<Result> SaveClientAsync(ClientAccountEntity client, CancellationToken cancellationToken = default);
+    public Task<Result<ChannelEntity>> GetChannelByIdAsync(string id, CancellationToken cancellationToken = default);
+
+    public Task<Result> SaveChannelAsync(InnertubeChannel innertubeChannel, CancellationToken cancellationToken = default);
    public Task<Result<LibraryInformation>> GetLibraryInfoAsync(CancellationToken cancellationToken = default);
+
+    public Task<ListResult<ChannelEntity>> GetChannelsAsync(int total = 20, int offset = 0, CancellationToken cancellationToken = default);
 }
--- a/Manager.App/Services/LibraryService.cs
+++ b/Manager.App/Services/LibraryService.cs
@@ -1,8 +1,12 @@
 using DotBased.Monads;
+using Manager.App.Constants;
 using Manager.App.Models.Library;
 using Manager.App.Models.Settings;
+using Manager.App.Models.System;
+using Manager.App.Services.System;
 using Manager.Data.Contexts;
 using Manager.Data.Entities.LibraryContext;
+using Manager.YouTube.Models.Innertube;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Options;

@@ -14,18 +18,210 @@ public class LibraryService : ILibraryService
    private readonly LibrarySettings _librarySettings;
    private readonly IDbContextFactory<LibraryDbContext> _dbContextFactory;
    private readonly DirectoryInfo _libraryDirectory;
-    private const string SubDirMedia = "Media";
-    private const string SubDirChannels = "Channels";
-
-    public LibraryService(ILogger<LibraryService> logger, IOptions<LibrarySettings> librarySettings, IDbContextFactory<LibraryDbContext> contextFactory)
+    private readonly CacheService _cacheService;
+    
+    public LibraryService(ILogger<LibraryService> logger, IOptions<LibrarySettings> librarySettings, IDbContextFactory<LibraryDbContext> contextFactory, CacheService cacheService)
    {
        _logger = logger;
        _librarySettings = librarySettings.Value;
        _dbContextFactory = contextFactory;
+        _cacheService = cacheService;
        _libraryDirectory = Directory.CreateDirectory(_librarySettings.Path);
-        logger.LogDebug("Working dir for library: {LibraryWorkingDir}", _libraryDirectory.FullName);
-        Directory.CreateDirectory(Path.Combine(_librarySettings.Path, SubDirMedia));
-        Directory.CreateDirectory(Path.Combine(_librarySettings.Path, SubDirChannels));
+        logger.LogDebug("Library directory: {LibraryWorkingDir}", _libraryDirectory.FullName);
+        Directory.CreateDirectory(Path.Combine(_librarySettings.Path, LibraryConstants.Directories.SubDirMedia));
+        Directory.CreateDirectory(Path.Combine(_librarySettings.Path, LibraryConstants.Directories.SubDirChannels));
+    }
+    
+    public async Task<Result> FetchChannelImagesAsync(InnertubeChannel innertubeChannel)
+    {
+        try
+        {
+            await using var context = await _dbContextFactory.CreateDbContextAsync();
+            
+            await AddWebImagesAsync(context, innertubeChannel.AvatarImages, innertubeChannel.Id, "avatars", LibraryConstants.FileTypes.ChannelAvatar, LibraryConstants.Directories.SubDirChannels);
+            await AddWebImagesAsync(context, innertubeChannel.BannerImages, innertubeChannel.Id, "banners", LibraryConstants.FileTypes.ChannelBanner, LibraryConstants.Directories.SubDirChannels);
+
+            if (!context.ChangeTracker.HasChanges())
+            {
+                _logger.LogInformation("No changes detected. Skipping.");
+                return Result.Success();
+            }
+
+            await context.SaveChangesAsync();
+        }
+        catch (Exception e)
+        {
+            return ResultError.Error(e);
+        }
+        
+        return Result.Success();
+    }
+
+    private async Task AddWebImagesAsync(LibraryDbContext context, List<WebImage> images, string foreignKey, string libSubDir, string fileType, string subDir)
+    {
+        foreach (var image in images)
+        {
+            if (context.Files.Any(f => image.Url.Equals(f.OriginalUrl, StringComparison.OrdinalIgnoreCase)))
+            {
+                continue;
+            }
+
+            var cacheResult = await _cacheService.CacheFromUrl(image.Url);
+            if (!cacheResult.IsSuccess)
+            {
+                _logger.LogWarning("Failed to get image {ImageUrl}", image.Url);
+                continue;
+            }
+
+            var cachedFile = cacheResult.Value;
+            
+            var fileId = Guid.NewGuid();
+            var fileName = cachedFile.OriginalFileName ?? $"{fileId}.{cachedFile.ContentType?.Split('/').Last() ?? "unknown"}";
+            var relativePath = Path.Combine(foreignKey, libSubDir, $"{DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}_{fileName}");
+            var savePath = Path.Combine(_libraryDirectory.FullName, subDir, relativePath);
+            Directory.CreateDirectory(Path.GetDirectoryName(savePath) ?? savePath);
+            await using var fileStream = File.Create(savePath);
+            await fileStream.WriteAsync(cachedFile.Data.AsMemory(0, cachedFile.Data.Length));
+            
+            var file = new FileEntity
+            {
+                Id = fileId,
+                OriginalUrl = image.Url,
+                OriginalFileName = cachedFile.OriginalFileName,
+                ForeignKey = foreignKey,
+                FileType = fileType,
+                RelativePath = relativePath.Replace('\\', '/'),
+                MimeType = cachedFile.ContentType,
+                SizeBytes = cachedFile.Data.Length,
+                Height = image.Height,
+                Width = image.Width
+            };
+            
+            await context.Files.AddAsync(file);
+        }
+    }
+
+    public async Task<Result> SaveClientAsync(ClientAccountEntity client, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await using var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+            var updateEntity = false;
+            var dbClient = context.ClientAccounts.FirstOrDefault(c => c.Id == client.Id);
+            if (dbClient == null)
+            {
+                dbClient = client;
+            }
+            else
+            {
+                updateEntity = true;
+                dbClient.HttpCookies = client.HttpCookies;
+                dbClient.UserAgent = client.UserAgent;
+            }
+
+            if (updateEntity)
+            {
+                context.ClientAccounts.Update(dbClient);
+            }
+            else
+            {
+                context.ClientAccounts.Add(dbClient);
+            }
+
+            var savedResult= await context.SaveChangesAsync(cancellationToken);
+            return savedResult <= 0 ? ResultError.Fail("Could not save changes!") : Result.Success();
+        }
+        catch (Exception e)
+        {
+            return ResultError.Error(e);
+        }
+    }
+
+    public async Task<Result<ChannelEntity>> GetChannelByIdAsync(string id, CancellationToken cancellationToken = default)
+    {
+        if (string.IsNullOrWhiteSpace(id))
+        {
+            return ResultError.Fail("Channel id cannot be null or empty!");
+        }
+
+        try
+        {
+            await using var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            var channel = await context.Channels
+                .Include(c => c.ClientAccount)
+                .ThenInclude(p => p!.HttpCookies)
+                .FirstOrDefaultAsync(c => c.Id == id, cancellationToken);
+            
+            if (channel == null)
+            {
+                return ResultError.Fail("Channel not found!");
+            }
+
+            return channel;
+        }
+        catch (Exception e)
+        {
+            return HandleException(e);
+        }
+    }
+
+    public async Task<Result> SaveChannelAsync(InnertubeChannel innertubeChannel, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var imagesResult = await FetchChannelImagesAsync(innertubeChannel);
+            if (!imagesResult.IsSuccess)
+            {
+                return ResultError.Fail("Failed to fetch channel images!");
+            }
+            
+            await using var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            
+            var channelResult = await GetChannelByIdAsync(innertubeChannel.Id, cancellationToken);
+
+            ChannelEntity? channelEntity;
+            try
+            {
+                if (channelResult.IsSuccess)
+                {
+                    channelEntity = channelResult.Value;
+                    channelEntity.Name = innertubeChannel.ChannelName;
+                    channelEntity.Handle = innertubeChannel.Handle;
+                    channelEntity.Description = innertubeChannel.Description;
+                }
+                else
+                {
+                    channelEntity = new ChannelEntity
+                    {
+                        Id = innertubeChannel.Id,
+                        Name = innertubeChannel.ChannelName,
+                        Handle = innertubeChannel.Handle,
+                        Description = innertubeChannel.Description
+                    };
+                }
+            }
+            catch (Exception e)
+            {
+                return ResultError.Error(e);
+            }
+            
+            if (context.Channels.Any(c => c.Id == innertubeChannel.Id))
+            {
+                context.Channels.Update(channelEntity);
+            }
+            else
+            {
+                context.Channels.Add(channelEntity);
+            }
+            
+            var changed = await context.SaveChangesAsync(cancellationToken);
+            return changed <= 0 ? ResultError.Fail("Failed to save channel!") : Result.Success();
+        }
+        catch (Exception e)
+        {
+            return HandleException(e);
+        }
    }

    public async Task<Result<LibraryInformation>> GetLibraryInfoAsync(CancellationToken cancellationToken = default)
@@ -50,13 +246,13 @@ public class LibraryService : ILibraryService
        }
    }

-    public async Task<Result<List<ChannelEntity>>> GetAccountsAsync(int total = 20, int offset = 0, CancellationToken cancellationToken = default)
+    public async Task<ListResult<ChannelEntity>> GetChannelsAsync(int total = 20, int offset = 0, CancellationToken cancellationToken = default)
    {
        try
        {
            await using var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-            var orderedAccounts = context.Channels.Include(x => x.ClientAccount).Where(x => x.ClientAccount != null).OrderBy(x => x.Id).Skip(offset).Take(total);
-            return orderedAccounts.ToList();
+            var orderedAccounts = context.Channels.Include(x => x.ClientAccount).Where(x => x.ClientAccount != null).OrderBy(x => x.Id);
+            return new ListResultReturn<ChannelEntity>(orderedAccounts.Skip(offset).Take(total).ToList(),orderedAccounts.Count());
        }
        catch (Exception e)
        {
--- a/Manager.App/Services/System/BackgroundServiceRegistry.cs
+++ b/Manager.App/Services/System/BackgroundServiceRegistry.cs
@@ -0,0 +1,9 @@
+namespace Manager.App.Services.System;
+
+public class BackgroundServiceRegistry(IEnumerable<ExtendedBackgroundService> backgroundServices)
+{
+    public List<ExtendedBackgroundService> GetServices()
+    {
+        return backgroundServices.ToList();
+    }
+}
--- a/Manager.App/Services/System/CacheService.cs
+++ b/Manager.App/Services/System/CacheService.cs
@@ -0,0 +1,184 @@
+using System.Security.Cryptography;
+using System.Text;
+using DotBased.Logging;
+using DotBased.Monads;
+using Manager.Data.Contexts;
+using Manager.Data.Entities.Cache;
+using Manager.YouTube;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+
+namespace Manager.App.Services.System;
+
+public class CacheService(ILogger<CacheService> logger, IHostEnvironment environment) : ExtendedBackgroundService(nameof(CacheService), "Manages caching.", logger, TimeSpan.FromHours(5))
+{
+    private DirectoryInfo? _cacheDirectory;
+    private PooledDbContextFactory<CacheDbContext>? _dbContextFactory;
+    private const string DataSubDir = "data";
+    
+    protected override Task InitializeAsync(CancellationToken stoppingToken)
+    {
+        _cacheDirectory = new DirectoryInfo(Path.Combine(Directory.GetCurrentDirectory(), "cache"));
+        _cacheDirectory.Create();
+        Directory.CreateDirectory(Path.Combine(_cacheDirectory.FullName, DataSubDir));
+        LogEvent($"Cache directory: {_cacheDirectory.FullName}");
+        
+        var dbContextOptionsBuilder = new DbContextOptionsBuilder<CacheDbContext>();
+        dbContextOptionsBuilder.UseSqlite($"Data Source={Path.Combine(_cacheDirectory.FullName, "cache_index.db")}");
+        _dbContextFactory = new PooledDbContextFactory<CacheDbContext>(dbContextOptionsBuilder.Options);
+        
+        return Task.CompletedTask;
+    }
+
+    protected override async Task ExecuteServiceAsync(CancellationToken stoppingToken)
+    {
+        if (environment.IsDevelopment())
+        {
+            LogEvent("Development mode detected, skipping cache cleaning...");
+            return;
+        }
+
+        try
+        {
+            await ClearCacheAsync(stoppingToken);
+        }
+        catch (Exception e)
+        {
+            logger.LogError(e, "Error in execution of service.");
+            LogEvent($"Service execution failed. {e.Message}", LogSeverity.Error);
+            throw;
+        }
+    }
+
+    public string CreateCacheUrl(string originalUrl) => $"/api/v1/cache?url={originalUrl}";
+
+    public async Task<Result<CacheFile>> CacheFromUrl(string url, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            if (string.IsNullOrWhiteSpace(url))
+            {
+                return ResultError.Fail("Url is empty.");
+            }
+
+            if (_cacheDirectory == null)
+            {
+                return ResultError.Fail("Cache directory is not initialized.");
+            }
+
+            if (_dbContextFactory == null)
+            {
+                return ResultError.Fail("Context factory is not initialized.");
+            }
+
+            await using var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            
+            var urlKeyBytes = SHA1.HashData(Encoding.UTF8.GetBytes(url));
+            var urlKey = Convert.ToHexString(urlKeyBytes);
+            var cacheEntity = await context.Cache.FirstOrDefaultAsync(c => c.Id == urlKey, cancellationToken: cancellationToken);
+            if (cacheEntity == null)
+            {
+                var downloadResult = await NetworkService.DownloadBytesAsync(new HttpRequestMessage(HttpMethod.Get, url));
+                if (!downloadResult.IsSuccess)
+                {
+                    LogEvent($"Failed to download from url: {url}");
+                    return ResultError.Fail("Download failed.");
+                }
+                var download = downloadResult.Value;
+                await using var downloadFile = File.Create(Path.Combine(_cacheDirectory.FullName, DataSubDir, $"{urlKey}.cache"));
+                await downloadFile.WriteAsync(download.Data.AsMemory(0, download.Data.Length), cancellationToken);
+
+                cacheEntity = new CacheEntity
+                {
+                    Id = urlKey,
+                    CachedAtUtc = DateTime.UtcNow,
+                    ContentLength = download.ContentLength,
+                    ContentType = download.ContentType,
+                    OriginalFileName = download.FileName,
+                };
+                
+                context.Cache.Add(cacheEntity);
+                var saved = await context.SaveChangesAsync(cancellationToken);
+                if (saved <= 0)
+                {
+                    LogEvent($"Cache entity {cacheEntity.Id} could not be saved.", LogSeverity.Error);
+                    return ResultError.Fail("Failed to save to cache db.");
+                }
+
+                return new CacheFile(download.Data, download.ContentType, download.FileName);
+            }
+
+            var filePath = Path.Combine(_cacheDirectory.FullName, DataSubDir, $"{urlKey}.cache");
+            var buffer = await File.ReadAllBytesAsync(filePath, cancellationToken);
+            if (buffer.Length == 0)
+            {
+                LogEvent($"Failed to read data from disk. File: {filePath}", LogSeverity.Error);
+                return ResultError.Fail($"Error reading data from disk. File: {filePath}");
+            }
+
+            return new CacheFile(buffer.ToArray(), cacheEntity.ContentType, cacheEntity.OriginalFileName);
+        }
+        catch (Exception e)
+        {
+            return ResultError.Error(e, "Cache error.");
+        }
+    }
+
+    private async Task ClearCacheAsync(CancellationToken cancellationToken)
+    {
+        if (_dbContextFactory == null)
+        {
+            throw new InvalidOperationException("No DbContext factory configured.");
+        }
+
+        if (_cacheDirectory == null)
+        {
+            throw new InvalidOperationException("No cache directory configured.");
+        }
+
+        await using var dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        
+        var toRemove = dbContext.Cache.Where(c => c.CachedAtUtc < DateTime.UtcNow.AddDays(-1));
+        if (!toRemove.Any())
+        {
+            LogEvent("No items found to purge from cache.");
+            return;
+        }
+
+        var totalToRemove = toRemove.Count();
+        LogEvent($"Found {totalToRemove} cache items that are older than 1 day(s)");
+        
+        var deleted = new List<CacheEntity>();
+        foreach (var entity in toRemove)
+        {
+            var pathToFile = Path.Combine(_cacheDirectory.FullName, DataSubDir, $"{entity.Id}.cache");
+            if (!File.Exists(pathToFile))
+            {
+                deleted.Add(entity);
+                continue;
+            }
+
+            try
+            {
+                File.Delete(pathToFile);
+            }
+            catch (Exception e)
+            {
+                logger.LogError(e, "Failed to delete cache entity with id: {EntityId}. Skipping cache entity...", entity.Id);
+                continue;
+            }
+            deleted.Add(entity);
+        }
+        
+        dbContext.RemoveRange(deleted);
+        var dbDeleted = await dbContext.SaveChangesAsync(cancellationToken);
+        if (dbDeleted < deleted.Count)
+        {
+            LogEvent("Could not delete all files from cache.", LogSeverity.Warning);
+        }
+
+        LogEvent($"Removed {dbDeleted}/{totalToRemove} items");
+    }
+}
+
+public record CacheFile(byte[] Data, string? ContentType, string? OriginalFileName);
--- a/Manager.App/Services/System/ClientManager.cs
+++ b/Manager.App/Services/System/ClientManager.cs
@@ -1,49 +0,0 @@
-using System.Net;
-using DotBased.Monads;
-using Manager.Data.Entities.LibraryContext;
-using Manager.YouTube;
-
-namespace Manager.App.Services.System;
-
-public class ClientManager : BackgroundService
-{
-    private readonly List<YouTubeClient> _clients = [];
-    private CancellationToken _cancellationToken;
-    
-    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
-    {
-        _cancellationToken = stoppingToken;
-        stoppingToken.Register(CancellationRequested);
-    }
-    
-    private void CancellationRequested()
-    {
-        // Clear up
-    }
-
-    public async Task<Result<YouTubeClient>> LoadClient(ClientAccountEntity accountEntity)
-    {
-        if (_cancellationToken.IsCancellationRequested)
-        {
-            return ResultError.Fail("Service is shutting down.");
-        }
-
-        var container = new CookieContainer();
-
-        if (accountEntity.HttpCookies.Count != 0)
-        {
-            var cookieColl = new CookieCollection();
-            foreach (var cookieEntity in accountEntity.HttpCookies)
-            {
-                cookieColl.Add(new Cookie(cookieEntity.Name, cookieEntity.Value, cookieEntity.Domain));
-            }
-            
-            container.Add(cookieColl);
-        }
-        
-        var ytClient = new YouTubeClient(container, accountEntity.UserAgent ?? "");
-        await ytClient.GetStateAsync();
-
-        return ytClient;
-    }
-}
--- a/Manager.App/Services/System/ClientService.cs
+++ b/Manager.App/Services/System/ClientService.cs
@@ -0,0 +1,112 @@
+using System.Net;
+using DotBased.Logging;
+using DotBased.Monads;
+using Manager.Data.Entities.LibraryContext;
+using Manager.YouTube;
+
+namespace Manager.App.Services.System;
+
+public class ClientService(IServiceScopeFactory scopeFactory, ILogger<ClientService> logger)
+    : ExtendedBackgroundService(nameof(ClientService), "Managing YouTube clients", logger, TimeSpan.FromMinutes(10))
+{
+    private readonly YouTubeClientCollection _loadedClients = [];
+    private ILibraryService? _libraryService;
+
+    protected override Task InitializeAsync(CancellationToken stoppingToken)
+    {
+        stoppingToken.Register(CancellationRequested);
+        using var scope = scopeFactory.CreateScope();
+        _libraryService = scope.ServiceProvider.GetRequiredService<ILibraryService>();
+        LogEvent("Initializing service...");
+        return Task.CompletedTask;
+    }
+
+    protected override async Task ExecuteServiceAsync(CancellationToken stoppingToken)
+    {
+        LogEvent($"Saving {_loadedClients.Count} loaded client(s)");
+        foreach (var client in _loadedClients)
+        {
+            await SaveClientAsync(client, cancellationToken: stoppingToken);
+        }
+    }
+    
+    private async void CancellationRequested()
+    {
+        foreach (var client in _loadedClients)
+        {
+            await SaveClientAsync(client);
+            client.Dispose();
+        }
+    }
+
+    public async Task<Result> AddClientByIdAsync(string id, CancellationToken stoppingToken = default)
+    {
+        if (_libraryService == null)
+        {
+            return ResultError.Fail("Library service is not initialized!.");
+        }
+        
+        var clientResult = await _libraryService.GetChannelByIdAsync(id, stoppingToken);
+        if (!clientResult.IsSuccess)
+        {
+            return clientResult;
+        }
+
+        var clientAcc = clientResult.Value.ClientAccount;
+        if (clientAcc == null)
+        {
+            return ResultError.Fail("Client account is not initialized!.");
+        }
+
+        var cookieCollection = new CookieCollection();
+        foreach (var httpCookie in clientAcc.HttpCookies)
+        {
+            var cookie = new Cookie
+            {
+                Name = httpCookie.Name,
+                Value = httpCookie.Value,
+                Domain = httpCookie.Domain,
+                Path = httpCookie.Path,
+                Secure = httpCookie.Secure,
+                HttpOnly = httpCookie.HttpOnly,
+                Expires = httpCookie.ExpiresUtc ?? DateTime.MinValue
+            };
+            cookieCollection.Add(cookie);
+        }
+        var ytClientResult = await YouTubeClient.CreateAsync(cookieCollection, clientAcc.UserAgent ?? "");
+        if (!ytClientResult.IsSuccess)
+        {
+            return ytClientResult;
+        }
+
+        AddClient(ytClientResult.Value);
+        return Result.Success();
+    }
+
+    public void AddClient(YouTubeClient client)
+    {
+        if (_loadedClients.Contains(client))
+        {
+            return;
+        }
+
+        _loadedClients.Add(client);
+    }
+
+    public async Task<Result> SaveClientAsync(YouTubeClient client, CancellationToken cancellationToken = default)
+    {
+        if (_libraryService == null)
+        {
+            return ResultError.Fail("Library service is not initialized!.");
+        }
+
+        if (string.IsNullOrWhiteSpace(client.Id))
+        {
+            LogEvent("Failed to store client no ID!", LogSeverity.Warning);
+            return ResultError.Fail("Client does not have an ID, cannot save to library database!");
+        }
+        
+        var saveResult = await _libraryService.SaveClientAsync(new ClientAccountEntity { Id = client.Id, UserAgent = client.UserAgent }, cancellationToken);
+        return saveResult;
+    }
+}
--- a/Manager.App/appsettings.Development.json
+++ b/Manager.App/appsettings.Development.json
@@ -3,11 +3,11 @@
    "Logging": {
      "Severity": "Debug",
      "SeverityFilters":{
-        "Microsoft": "Debug",
+        "Microsoft": "Info",
        "Microsoft.Hosting.Lifetime": "Debug",
        "Microsoft.AspNetCore": "Warning",
        "Microsoft.AspNetCore.Authentication": "Debug",
-        "MudBlazor": "Debug"
+        "MudBlazor": "Info"
      }
    }
  },
--- a/Manager.App/wwwroot/js/eventConsole.js
+++ b/Manager.App/wwwroot/js/eventConsole.js
@@ -0,0 +1,16 @@
+window.scrollToBottom = (element) => {
+    if (element) {
+        requestAnimationFrame(function () {
+            element.scroll({ top: element.scrollHeight, behavior: 'smooth' });
+        })
+    }
+};
+
+window.getScrollInfo = (element) => {
+    if (!element) return null;
+    return {
+        scrollTop: element.scrollTop,
+        scrollHeight: element.scrollHeight,
+        clientHeight: element.clientHeight
+    };
+};
--- a/Manager.App/wwwroot/js/tz.js
+++ b/Manager.App/wwwroot/js/tz.js
@@ -0,0 +1,3 @@
+function getUserTimeZone() {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
--- a/Manager.Data/Contexts/AuditInterceptor.cs
+++ b/Manager.Data/Contexts/AuditInterceptor.cs
@@ -0,0 +1,112 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Manager.Data.Entities.Audit;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.ChangeTracking;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+
+namespace Manager.Data.Contexts;
+
+public class AuditInterceptor : SaveChangesInterceptor
+{
+    public override InterceptionResult<int> SavingChanges(DbContextEventData eventData, InterceptionResult<int> result)
+    {
+        AddAudit(eventData.Context);
+        return base.SavingChanges(eventData, result);
+    }
+
+    public override ValueTask<InterceptionResult<int>> SavingChangesAsync(
+        DbContextEventData eventData,
+        InterceptionResult<int> result,
+        CancellationToken cancellationToken = default)
+    {
+        AddAudit(eventData.Context);
+        return base.SavingChangesAsync(eventData, result, cancellationToken);
+    }
+
+    private void AddAudit(DbContext? context)
+    {
+        if (context == null) return;
+
+        var entries = context.ChangeTracker.Entries()
+            .Where(e => e.State is EntityState.Modified or EntityState.Deleted or EntityState.Added && Attribute.IsDefined(e.Entity.GetType(),
+                typeof(AuditableAttribute)));
+
+        var audits = new List<EntityAudit>();
+
+        foreach (var entry in entries)
+        {
+            var primaryKey = entry.Properties.First(p => p.Metadata.IsPrimaryKey()).CurrentValue?.ToString();
+            
+            var declaredProperties = entry.Entity.GetType()
+                .GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance)
+                .Where(p => !Attribute.IsDefined(p.DeclaringType!, typeof(NoAuditAttribute), false))
+                .Select(p => p.Name)
+                .ToHashSet();
+
+            var allowedProperties = entry.Properties.Where(p => declaredProperties.Contains(p.Metadata.Name));
+
+            switch (entry.State)
+            {
+                case EntityState.Added:
+                    audits.AddRange(allowedProperties
+                            .Where(p => p.CurrentValue != null)
+                            .Select(p => CreateAudit(entry, p, entry.State, primaryKey))
+                    );
+                    break;
+                case EntityState.Modified:
+                    audits.AddRange(allowedProperties
+                            .Where(p => p.IsModified)
+                            .Select(p => CreateAudit(entry, p, entry.State, primaryKey))
+                    );
+                    break;
+                case EntityState.Deleted:
+                    audits.AddRange(allowedProperties
+                            .Select(p => CreateAudit(entry, p, entry.State, primaryKey))
+                    );
+                    break;
+            }
+        }
+
+        if (audits.Count != 0)
+        {
+            context.Set<EntityAudit>().AddRange(audits);
+        }
+    }
+
+    private EntityAudit CreateAudit(EntityEntry entry, PropertyEntry prop, EntityState changeType, string? primaryKey)
+    {
+        return new EntityAudit
+        {
+            Id = Guid.NewGuid(),
+            EntityName = entry.Entity.GetType().Name,
+            EntityId = primaryKey ?? "Unknown",
+            PropertyName = prop.Metadata.Name,
+            OldValue = SerializeValue(prop.OriginalValue),
+            NewValue = SerializeValue(prop.CurrentValue),
+            ModifiedUtc = DateTime.UtcNow,
+            ChangedBy = "SYSTEM",
+            ChangeType = changeType
+        };
+    }
+
+    private readonly JsonSerializerOptions _jsonSerializerOptions = new()
+    {
+        WriteIndented = false,
+        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
+    };
+    
+    private string? SerializeValue(object? value)
+    {
+        if (value == null) return null;
+
+        var type = value.GetType();
+
+        if (type.IsPrimitive || type == typeof(string) || type == typeof(DateTime) || type == typeof(decimal))
+        {
+            return value.ToString();
+        }
+
+        return JsonSerializer.Serialize(value, _jsonSerializerOptions);
+    }
+}
--- a/Manager.Data/Contexts/CacheDbContext.cs
+++ b/Manager.Data/Contexts/CacheDbContext.cs
@@ -0,0 +1,25 @@
+using Manager.Data.Entities.Cache;
+using Microsoft.EntityFrameworkCore;
+
+namespace Manager.Data.Contexts;
+
+public sealed class CacheDbContext : DbContext
+{
+    public CacheDbContext(DbContextOptions<CacheDbContext> options) : base(options)
+    {
+        Database.EnsureCreated();
+    }
+
+    public DbSet<CacheEntity> Cache { get; set; }
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        modelBuilder.Entity<CacheEntity>(ce =>
+        {
+            ce.ToTable("cache");
+            ce.HasKey(x => x.Id);
+        });
+        
+        base.OnModelCreating(modelBuilder);
+    }
+}
--- a/Manager.Data/Contexts/DateInterceptor.cs
+++ b/Manager.Data/Contexts/DateInterceptor.cs
@@ -0,0 +1,38 @@
+using Manager.Data.Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+
+namespace Manager.Data.Contexts;
+
+public class DateInterceptor : SaveChangesInterceptor
+{
+    public override InterceptionResult<int> SavingChanges(DbContextEventData eventData, InterceptionResult<int> result)
+    {
+        UpdateEntryDates(eventData.Context);
+        return base.SavingChanges(eventData, result);
+    }
+
+    public override ValueTask<InterceptionResult<int>> SavingChangesAsync(DbContextEventData eventData, InterceptionResult<int> result,
+        CancellationToken cancellationToken = new())
+    {
+        UpdateEntryDates(eventData.Context);
+        return base.SavingChangesAsync(eventData, result, cancellationToken);
+    }
+    
+    private void UpdateEntryDates(DbContext? context)
+    {
+        if (context == null) return;
+
+        var entries = context.ChangeTracker.Entries().Where(x => x is { Entity: DateTimeBase, State: EntityState.Added or EntityState.Modified });
+
+        foreach (var entity in entries)
+        {
+            ((DateTimeBase)entity.Entity).LastModifiedUtc = DateTime.UtcNow;
+
+            if (entity.State == EntityState.Added)
+            {
+                ((DateTimeBase)entity.Entity).CreatedAtUtc = DateTime.UtcNow;
+            }
+        }
+    }
+}
--- a/Manager.Data/Contexts/LibraryDbContext.cs
+++ b/Manager.Data/Contexts/LibraryDbContext.cs
@@ -1,4 +1,4 @@
-using Manager.Data.Entities;
+using Manager.Data.Entities.Audit;
 using Manager.Data.Entities.LibraryContext;
 using Manager.Data.Entities.LibraryContext.Join;
 using Microsoft.EntityFrameworkCore;
@@ -13,17 +13,31 @@ public sealed class LibraryDbContext : DbContext
        ChangeTracker.LazyLoadingEnabled = false;
        Database.EnsureCreated();
    }
+    
+    public DbSet<EntityAudit> Histories { get; set; }

    public DbSet<CaptionEntity> Captions { get; set; }
    public DbSet<ChannelEntity> Channels { get; set; }
-    public DbSet<ClientAccountEntity> Accounts { get; set; }
+    public DbSet<ClientAccountEntity> ClientAccounts { get; set; }
    public DbSet<HttpCookieEntity> HttpCookies { get; set; }
    public DbSet<MediaEntity> Media { get; set; }
    public DbSet<MediaFormatEntity> MediaFormats { get; set; }
    public DbSet<PlaylistEntity> Playlists { get; set; }
+    public DbSet<FileEntity> Files { get; set; }
+
+    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+    {
+        optionsBuilder.AddInterceptors(new DateInterceptor(), new AuditInterceptor());
+    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
+        modelBuilder.Entity<EntityAudit>(ea =>
+        {
+            ea.HasKey(a => a.Id);
+            ea.ToTable("audits");
+        });
+        
        modelBuilder.Entity<CaptionEntity>(ce =>
        {
            ce.ToTable("captions");
@@ -83,6 +97,12 @@ public sealed class LibraryDbContext : DbContext
            ple.ToTable("playlists");
            ple.HasKey(x => x.Id);
        });
+
+        modelBuilder.Entity<FileEntity>(file =>
+        {
+            file.ToTable("files");
+            file.HasKey(x => x.Id);
+        });
        
        /* Join tables */

@@ -101,31 +121,4 @@ public sealed class LibraryDbContext : DbContext
        
        base.OnModelCreating(modelBuilder);
    }
-
-    public override int SaveChanges()
-    {
-        UpdateEntryDates();
-        return base.SaveChanges();
-    }
-
-    public override Task<int> SaveChangesAsync(bool acceptAllChangesOnSuccess, CancellationToken cancellationToken = new())
-    {
-        UpdateEntryDates();
-        return base.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken);
-    }
-
-    private void UpdateEntryDates()
-    {
-        var entries = ChangeTracker.Entries().Where(x => x is { Entity: DateTimeBase, State: EntityState.Added or EntityState.Modified });
-
-        foreach (var entity in entries)
-        {
-            ((DateTimeBase)entity.Entity).LastModifiedUtc = DateTime.UtcNow;
-
-            if (entity.State == EntityState.Added)
-            {
-                ((DateTimeBase)entity.Entity).CreatedAtUtc = DateTime.UtcNow;
-            }
-        }
-    }
 }
--- a/Manager.Data/DataConstants.cs
+++ b/Manager.Data/DataConstants.cs
@@ -4,7 +4,8 @@ public static class DataConstants
 {
    public static class DbContext
    {
-        public const int DefaultDbStringSize = 100;
-        public const int DefaultDbDescriptionStringSize = 500;
+        public const int DefaultDbStringSize = 500;
+        public const int DefaultDbDescriptionStringSize = 5500;
+        public const int DefaultDbUrlSize = 10000;
    }
 }
--- a/Manager.Data/Entities/Audit/AuditableAttribute.cs
+++ b/Manager.Data/Entities/Audit/AuditableAttribute.cs
@@ -0,0 +1,9 @@
+namespace Manager.Data.Entities.Audit;
+
+/// <summary>
+/// Make all properties in the entity audible, if they are changed this will be stored as a history in the db.
+/// </summary>
+[AttributeUsage(AttributeTargets.Class)]
+public class AuditableAttribute : Attribute
+{
+}
--- a/Manager.Data/Entities/Audit/EntityAudit.cs
+++ b/Manager.Data/Entities/Audit/EntityAudit.cs
@@ -0,0 +1,23 @@
+using System.ComponentModel.DataAnnotations;
+using Microsoft.EntityFrameworkCore;
+
+namespace Manager.Data.Entities.Audit;
+
+public class EntityAudit
+{
+    public required Guid Id { get; set; }
+    [MaxLength(200)]
+    public required string EntityName { get; set; }
+    [MaxLength(200)]
+    public required string EntityId { get; set; }
+    [MaxLength(200)]
+    public required string PropertyName { get; set; }
+    [MaxLength(1000)]
+    public string? OldValue { get; set; }
+    [MaxLength(1000)]
+    public string? NewValue { get; set; }
+    public DateTime ModifiedUtc { get; set; } = DateTime.UtcNow;
+    [MaxLength(200)]
+    public string? ChangedBy { get; set; }
+    public EntityState ChangeType { get; set; }
+}
--- a/Manager.Data/Entities/Audit/NoAuditAttribute.cs
+++ b/Manager.Data/Entities/Audit/NoAuditAttribute.cs
@@ -0,0 +1,9 @@
+namespace Manager.Data.Entities.Audit;
+
+/// <summary>
+/// Specifies to ignore the properties in the entity to not audit.
+/// </summary>
+[AttributeUsage(AttributeTargets.Class)]
+public class NoAuditAttribute : Attribute
+{
+}
--- a/Manager.Data/Entities/DateTimeBase.cs
+++ b/Manager.Data/Entities/DateTimeBase.cs
@@ -1,7 +1,10 @@
+using Manager.Data.Entities.Audit;
+
 namespace Manager.Data.Entities;

+[NoAudit]
 public abstract class DateTimeBase
 {
-    public DateTime CreatedAtUtc { get; set; } = DateTime.UtcNow;
-    public DateTime LastModifiedUtc { get; set; } = DateTime.UtcNow;
+    public DateTime CreatedAtUtc { get; set; }
+    public DateTime LastModifiedUtc { get; set; }
 }
--- a/Manager.Data/Entities/LibraryContext/CaptionEntity.cs
+++ b/Manager.Data/Entities/LibraryContext/CaptionEntity.cs
@@ -1,7 +1,9 @@
 using System.ComponentModel.DataAnnotations;
+using Manager.Data.Entities.Audit;

 namespace Manager.Data.Entities.LibraryContext;

+[Auditable]
 public class CaptionEntity : DateTimeBase
 {
    [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
--- a/Manager.Data/Entities/LibraryContext/ChannelEntity.cs
+++ b/Manager.Data/Entities/LibraryContext/ChannelEntity.cs
@@ -1,19 +1,19 @@
 using System.ComponentModel.DataAnnotations;
+using Manager.Data.Entities.Audit;

 namespace Manager.Data.Entities.LibraryContext;

+[Auditable]
 public class ChannelEntity : DateTimeBase
 {
    [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
    public required string Id { get; set; }
    [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
    public string? Name { get; set; }
+    [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
+    public string? Handle { get; set; }
    [MaxLength(DataConstants.DbContext.DefaultDbDescriptionStringSize)]
    public string? Description { get; set; }
-    public DateTime JoinedDate { get; set; }
-    public long Subscribers { get; set; }
-    public long TotalVideos { get; set; }
-    public long TotalViews { get; set; }
    public List<MediaEntity> Media { get; set; } = [];
    public List<PlaylistEntity> Playlists { get; set; } = [];
    public ClientAccountEntity? ClientAccount { get; set; }
--- a/Manager.Data/Entities/LibraryContext/ClientAccountEntity.cs
+++ b/Manager.Data/Entities/LibraryContext/ClientAccountEntity.cs
@@ -1,7 +1,9 @@
 using System.ComponentModel.DataAnnotations;
+using Manager.Data.Entities.Audit;

 namespace Manager.Data.Entities.LibraryContext;

+[Auditable]
 public class ClientAccountEntity : DateTimeBase
 {
    [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
--- a/Manager.Data/Entities/LibraryContext/FileEntity.cs
+++ b/Manager.Data/Entities/LibraryContext/FileEntity.cs
@@ -0,0 +1,25 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Manager.Data.Entities.LibraryContext;
+
+public class FileEntity : DateTimeBase
+{
+    public required Guid Id { get; set; }
+    [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
+    public required string ForeignKey { get; set; }
+    [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
+    public required string FileType { get; set; }
+    [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
+    public required string RelativePath { get; set; }
+    [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
+    public string? MimeType { get; set; }
+    public long SizeBytes { get; set; }
+    [MaxLength(DataConstants.DbContext.DefaultDbUrlSize)]
+    public string? OriginalUrl { get; set; }
+    [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
+    public string? OriginalFileName { get; set; }
+
+    public int? Width { get; set; }
+    public int? Height { get; set; }
+    public long? LenghtMilliseconds { get; set; }
+}
--- a/Manager.Data/Entities/LibraryContext/HttpCookieEntity.cs
+++ b/Manager.Data/Entities/LibraryContext/HttpCookieEntity.cs
@@ -1,9 +1,13 @@
 using System.ComponentModel.DataAnnotations;
+using Manager.Data.Entities.Audit;

 namespace Manager.Data.Entities.LibraryContext;

+[NoAudit]
 public class HttpCookieEntity : DateTimeBase
 {
+    [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
+    public required string ClientId { get; set; }
    [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
    public required string Name { get; set; }
    [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
@@ -12,11 +16,7 @@ public class HttpCookieEntity : DateTimeBase
    public string? Domain { get; set; }
    [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
    public string? Path { get; set; }
-    public DateTimeOffset? ExpiresUtc { get; set; }
+    public DateTime? ExpiresUtc { get; set; }
    public bool Secure { get; set; }
    public bool HttpOnly { get; set; }
-    [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
-    public string? SameSite { get; set; }
-    [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
-    public required string ClientId { get; set; }
 }
--- a/Manager.Data/Entities/LibraryContext/MediaEntity.cs
+++ b/Manager.Data/Entities/LibraryContext/MediaEntity.cs
@@ -1,8 +1,10 @@
 using System.ComponentModel.DataAnnotations;
+using Manager.Data.Entities.Audit;
 using Manager.Data.Entities.LibraryContext.Join;

 namespace Manager.Data.Entities.LibraryContext;

+[Auditable]
 public class MediaEntity : DateTimeBase
 {
    [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
@@ -17,7 +19,6 @@ public class MediaEntity : DateTimeBase
    public List<MediaFormatEntity> Formats { get; set; } = [];
    public List<CaptionEntity> Captions { get; set; } = [];
    public List<PlaylistMedia> PlaylistMedias { get; set; } = [];
-    
    public MediaExternalState ExternalState { get; set; } = MediaExternalState.Online;
    public bool IsDownloaded { get; set; }
    public MediaState State { get; set; } = MediaState.Indexed;
--- a/Manager.Data/Entities/LibraryContext/PlaylistEntity.cs
+++ b/Manager.Data/Entities/LibraryContext/PlaylistEntity.cs
@@ -1,8 +1,10 @@
 using System.ComponentModel.DataAnnotations;
+using Manager.Data.Entities.Audit;
 using Manager.Data.Entities.LibraryContext.Join;

 namespace Manager.Data.Entities.LibraryContext;

+[Auditable]
 public class PlaylistEntity : DateTimeBase
 {
    [MaxLength(DataConstants.DbContext.DefaultDbStringSize)]
--- a/Manager.Data/Migrations/20250902141251_InitialLibrary.Designer.cs
+++ b/Manager.Data/Migrations/20250902141251_InitialLibrary.Designer.cs
@@ -1,424 +0,0 @@
-// <auto-generated />
-using System;
-using Manager.Data.Contexts;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Migrations;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-
-#nullable disable
-
-namespace Manager.Data.Migrations
-{
-    [DbContext(typeof(LibraryDbContext))]
-    [Migration("20250902141251_InitialLibrary")]
-    partial class InitialLibrary
-    {
-        /// <inheritdoc />
-        protected override void BuildTargetModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder.HasAnnotation("ProductVersion", "8.0.19");
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.CaptionEntity", b =>
-                {
-                    b.Property<string>("MediaId")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("LanguageCode")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("CreatedAtUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("LastModifiedUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.HasKey("MediaId", "LanguageCode");
-
-                    b.ToTable("captions", (string)null);
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.ChannelEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("CreatedAtUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Description")
-                        .HasMaxLength(500)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("JoinedDate")
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("LastModifiedUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Name")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("Subscribers")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<long>("TotalVideos")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<long>("TotalViews")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("channels", (string)null);
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.ClientAccountEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("CreatedAtUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("LastModifiedUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("UserAgent")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("client_accounts", (string)null);
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.HttpCookieEntity", b =>
-                {
-                    b.Property<string>("Name")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("ClientId")
-                        .IsRequired()
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("CreatedAtUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Domain")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTimeOffset?>("ExpiresUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<bool>("HttpOnly")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<DateTime>("LastModifiedUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Path")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("SameSite")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<bool>("Secure")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<string>("Value")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.HasKey("Name");
-
-                    b.HasIndex("ClientId");
-
-                    b.ToTable("http_cookies", (string)null);
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.Join.PlaylistMedia", b =>
-                {
-                    b.Property<string>("PlaylistId")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("MediaId")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("CreatedAtUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("LastModifiedUtc")
-                        .HasColumnType("TEXT");
-
-                    b.HasKey("PlaylistId", "MediaId");
-
-                    b.HasIndex("MediaId");
-
-                    b.ToTable("join_playlist_media", (string)null);
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.MediaEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("ChannelId")
-                        .IsRequired()
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("CreatedAtUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Description")
-                        .HasMaxLength(500)
-                        .HasColumnType("TEXT");
-
-                    b.Property<int>("ExternalState")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<bool>("IsDownloaded")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<DateTime>("LastModifiedUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<int>("State")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<string>("Title")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("UploadDateUtc")
-                        .HasColumnType("TEXT");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ChannelId");
-
-                    b.ToTable("media", (string)null);
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.MediaFormatEntity", b =>
-                {
-                    b.Property<string>("MediaId")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<int>("Itag")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<long>("ApproxDurationMs")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<int?>("AudioChannels")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<string>("AudioSampleRate")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("AverageBitrate")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<long>("Bitrate")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<long>("ContentLengthBytes")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<DateTime>("CreatedAtUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<double?>("Framerate")
-                        .HasColumnType("REAL");
-
-                    b.Property<int?>("Height")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<bool>("IsAdaptive")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<long>("LastModifiedUnixEpoch")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<DateTime>("LastModifiedUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<double?>("LoudnessDb")
-                        .HasColumnType("REAL");
-
-                    b.Property<string>("MimeType")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Quality")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("QualityLabel")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<int?>("Width")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("MediaId", "Itag");
-
-                    b.ToTable("media_formats", (string)null);
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.PlaylistEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("ChannelId")
-                        .IsRequired()
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("CreatedAtUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Description")
-                        .HasMaxLength(500)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("LastModifiedUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ChannelId");
-
-                    b.ToTable("playlists", (string)null);
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.CaptionEntity", b =>
-                {
-                    b.HasOne("Manager.Data.Entities.LibraryContext.MediaEntity", null)
-                        .WithMany("Captions")
-                        .HasForeignKey("MediaId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.ClientAccountEntity", b =>
-                {
-                    b.HasOne("Manager.Data.Entities.LibraryContext.ChannelEntity", null)
-                        .WithOne("ClientAccount")
-                        .HasForeignKey("Manager.Data.Entities.LibraryContext.ClientAccountEntity", "Id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.HttpCookieEntity", b =>
-                {
-                    b.HasOne("Manager.Data.Entities.LibraryContext.ClientAccountEntity", null)
-                        .WithMany("HttpCookies")
-                        .HasForeignKey("ClientId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.Join.PlaylistMedia", b =>
-                {
-                    b.HasOne("Manager.Data.Entities.LibraryContext.MediaEntity", null)
-                        .WithMany("PlaylistMedias")
-                        .HasForeignKey("MediaId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Manager.Data.Entities.LibraryContext.PlaylistEntity", null)
-                        .WithMany("PlaylistMedias")
-                        .HasForeignKey("PlaylistId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.MediaEntity", b =>
-                {
-                    b.HasOne("Manager.Data.Entities.LibraryContext.ChannelEntity", null)
-                        .WithMany("Media")
-                        .HasForeignKey("ChannelId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.MediaFormatEntity", b =>
-                {
-                    b.HasOne("Manager.Data.Entities.LibraryContext.MediaEntity", null)
-                        .WithMany("Formats")
-                        .HasForeignKey("MediaId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.PlaylistEntity", b =>
-                {
-                    b.HasOne("Manager.Data.Entities.LibraryContext.ChannelEntity", null)
-                        .WithMany("Playlists")
-                        .HasForeignKey("ChannelId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.ChannelEntity", b =>
-                {
-                    b.Navigation("ClientAccount");
-
-                    b.Navigation("Media");
-
-                    b.Navigation("Playlists");
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.ClientAccountEntity", b =>
-                {
-                    b.Navigation("HttpCookies");
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.MediaEntity", b =>
-                {
-                    b.Navigation("Captions");
-
-                    b.Navigation("Formats");
-
-                    b.Navigation("PlaylistMedias");
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.PlaylistEntity", b =>
-                {
-                    b.Navigation("PlaylistMedias");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}
--- a/Manager.Data/Migrations/20250902141251_InitialLibrary.cs
+++ b/Manager.Data/Migrations/20250902141251_InitialLibrary.cs
@@ -1,259 +0,0 @@
-using System;
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace Manager.Data.Migrations
-{
-    /// <inheritdoc />
-    public partial class InitialLibrary : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.CreateTable(
-                name: "channels",
-                columns: table => new
-                {
-                    Id = table.Column<string>(type: "TEXT", maxLength: 100, nullable: false),
-                    Name = table.Column<string>(type: "TEXT", maxLength: 100, nullable: true),
-                    Description = table.Column<string>(type: "TEXT", maxLength: 500, nullable: true),
-                    JoinedDate = table.Column<DateTime>(type: "TEXT", nullable: false),
-                    Subscribers = table.Column<long>(type: "INTEGER", nullable: false),
-                    TotalVideos = table.Column<long>(type: "INTEGER", nullable: false),
-                    TotalViews = table.Column<long>(type: "INTEGER", nullable: false),
-                    CreatedAtUtc = table.Column<DateTime>(type: "TEXT", nullable: false),
-                    LastModifiedUtc = table.Column<DateTime>(type: "TEXT", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_channels", x => x.Id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "client_accounts",
-                columns: table => new
-                {
-                    Id = table.Column<string>(type: "TEXT", maxLength: 100, nullable: false),
-                    UserAgent = table.Column<string>(type: "TEXT", maxLength: 100, nullable: true),
-                    CreatedAtUtc = table.Column<DateTime>(type: "TEXT", nullable: false),
-                    LastModifiedUtc = table.Column<DateTime>(type: "TEXT", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_client_accounts", x => x.Id);
-                    table.ForeignKey(
-                        name: "FK_client_accounts_channels_Id",
-                        column: x => x.Id,
-                        principalTable: "channels",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "media",
-                columns: table => new
-                {
-                    Id = table.Column<string>(type: "TEXT", maxLength: 100, nullable: false),
-                    Title = table.Column<string>(type: "TEXT", maxLength: 100, nullable: true),
-                    Description = table.Column<string>(type: "TEXT", maxLength: 500, nullable: true),
-                    UploadDateUtc = table.Column<DateTime>(type: "TEXT", nullable: false),
-                    ChannelId = table.Column<string>(type: "TEXT", maxLength: 100, nullable: false),
-                    ExternalState = table.Column<int>(type: "INTEGER", nullable: false),
-                    IsDownloaded = table.Column<bool>(type: "INTEGER", nullable: false),
-                    State = table.Column<int>(type: "INTEGER", nullable: false),
-                    CreatedAtUtc = table.Column<DateTime>(type: "TEXT", nullable: false),
-                    LastModifiedUtc = table.Column<DateTime>(type: "TEXT", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_media", x => x.Id);
-                    table.ForeignKey(
-                        name: "FK_media_channels_ChannelId",
-                        column: x => x.ChannelId,
-                        principalTable: "channels",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "playlists",
-                columns: table => new
-                {
-                    Id = table.Column<string>(type: "TEXT", maxLength: 100, nullable: false),
-                    Name = table.Column<string>(type: "TEXT", maxLength: 100, nullable: false),
-                    Description = table.Column<string>(type: "TEXT", maxLength: 500, nullable: true),
-                    ChannelId = table.Column<string>(type: "TEXT", maxLength: 100, nullable: false),
-                    CreatedAtUtc = table.Column<DateTime>(type: "TEXT", nullable: false),
-                    LastModifiedUtc = table.Column<DateTime>(type: "TEXT", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_playlists", x => x.Id);
-                    table.ForeignKey(
-                        name: "FK_playlists_channels_ChannelId",
-                        column: x => x.ChannelId,
-                        principalTable: "channels",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "http_cookies",
-                columns: table => new
-                {
-                    Name = table.Column<string>(type: "TEXT", maxLength: 100, nullable: false),
-                    Value = table.Column<string>(type: "TEXT", maxLength: 100, nullable: true),
-                    Domain = table.Column<string>(type: "TEXT", maxLength: 100, nullable: true),
-                    Path = table.Column<string>(type: "TEXT", maxLength: 100, nullable: true),
-                    ExpiresUtc = table.Column<DateTimeOffset>(type: "TEXT", nullable: true),
-                    Secure = table.Column<bool>(type: "INTEGER", nullable: false),
-                    HttpOnly = table.Column<bool>(type: "INTEGER", nullable: false),
-                    SameSite = table.Column<string>(type: "TEXT", maxLength: 100, nullable: true),
-                    ClientId = table.Column<string>(type: "TEXT", maxLength: 100, nullable: false),
-                    CreatedAtUtc = table.Column<DateTime>(type: "TEXT", nullable: false),
-                    LastModifiedUtc = table.Column<DateTime>(type: "TEXT", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_http_cookies", x => x.Name);
-                    table.ForeignKey(
-                        name: "FK_http_cookies_client_accounts_ClientId",
-                        column: x => x.ClientId,
-                        principalTable: "client_accounts",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "captions",
-                columns: table => new
-                {
-                    MediaId = table.Column<string>(type: "TEXT", maxLength: 100, nullable: false),
-                    LanguageCode = table.Column<string>(type: "TEXT", maxLength: 100, nullable: false),
-                    Name = table.Column<string>(type: "TEXT", maxLength: 100, nullable: false),
-                    CreatedAtUtc = table.Column<DateTime>(type: "TEXT", nullable: false),
-                    LastModifiedUtc = table.Column<DateTime>(type: "TEXT", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_captions", x => new { x.MediaId, x.LanguageCode });
-                    table.ForeignKey(
-                        name: "FK_captions_media_MediaId",
-                        column: x => x.MediaId,
-                        principalTable: "media",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "media_formats",
-                columns: table => new
-                {
-                    MediaId = table.Column<string>(type: "TEXT", maxLength: 100, nullable: false),
-                    Itag = table.Column<int>(type: "INTEGER", nullable: false),
-                    Quality = table.Column<string>(type: "TEXT", maxLength: 100, nullable: true),
-                    IsAdaptive = table.Column<bool>(type: "INTEGER", nullable: false),
-                    MimeType = table.Column<string>(type: "TEXT", maxLength: 100, nullable: true),
-                    Bitrate = table.Column<long>(type: "INTEGER", nullable: false),
-                    AverageBitrate = table.Column<long>(type: "INTEGER", nullable: false),
-                    LastModifiedUnixEpoch = table.Column<long>(type: "INTEGER", nullable: false),
-                    ContentLengthBytes = table.Column<long>(type: "INTEGER", nullable: false),
-                    ApproxDurationMs = table.Column<long>(type: "INTEGER", nullable: false),
-                    Width = table.Column<int>(type: "INTEGER", nullable: true),
-                    Height = table.Column<int>(type: "INTEGER", nullable: true),
-                    Framerate = table.Column<double>(type: "REAL", nullable: true),
-                    QualityLabel = table.Column<string>(type: "TEXT", maxLength: 100, nullable: true),
-                    AudioChannels = table.Column<int>(type: "INTEGER", nullable: true),
-                    AudioSampleRate = table.Column<string>(type: "TEXT", maxLength: 100, nullable: true),
-                    LoudnessDb = table.Column<double>(type: "REAL", nullable: true),
-                    CreatedAtUtc = table.Column<DateTime>(type: "TEXT", nullable: false),
-                    LastModifiedUtc = table.Column<DateTime>(type: "TEXT", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_media_formats", x => new { x.MediaId, x.Itag });
-                    table.ForeignKey(
-                        name: "FK_media_formats_media_MediaId",
-                        column: x => x.MediaId,
-                        principalTable: "media",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "join_playlist_media",
-                columns: table => new
-                {
-                    PlaylistId = table.Column<string>(type: "TEXT", maxLength: 100, nullable: false),
-                    MediaId = table.Column<string>(type: "TEXT", maxLength: 100, nullable: false),
-                    CreatedAtUtc = table.Column<DateTime>(type: "TEXT", nullable: false),
-                    LastModifiedUtc = table.Column<DateTime>(type: "TEXT", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_join_playlist_media", x => new { x.PlaylistId, x.MediaId });
-                    table.ForeignKey(
-                        name: "FK_join_playlist_media_media_MediaId",
-                        column: x => x.MediaId,
-                        principalTable: "media",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                    table.ForeignKey(
-                        name: "FK_join_playlist_media_playlists_PlaylistId",
-                        column: x => x.PlaylistId,
-                        principalTable: "playlists",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateIndex(
-                name: "IX_http_cookies_ClientId",
-                table: "http_cookies",
-                column: "ClientId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_join_playlist_media_MediaId",
-                table: "join_playlist_media",
-                column: "MediaId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_media_ChannelId",
-                table: "media",
-                column: "ChannelId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_playlists_ChannelId",
-                table: "playlists",
-                column: "ChannelId");
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropTable(
-                name: "captions");
-
-            migrationBuilder.DropTable(
-                name: "http_cookies");
-
-            migrationBuilder.DropTable(
-                name: "join_playlist_media");
-
-            migrationBuilder.DropTable(
-                name: "media_formats");
-
-            migrationBuilder.DropTable(
-                name: "client_accounts");
-
-            migrationBuilder.DropTable(
-                name: "playlists");
-
-            migrationBuilder.DropTable(
-                name: "media");
-
-            migrationBuilder.DropTable(
-                name: "channels");
-        }
-    }
-}
--- a/Manager.Data/Migrations/LibraryDbContextModelSnapshot.cs
+++ b/Manager.Data/Migrations/LibraryDbContextModelSnapshot.cs
@@ -1,421 +0,0 @@
-// <auto-generated />
-using System;
-using Manager.Data.Contexts;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-
-#nullable disable
-
-namespace Manager.Data.Migrations
-{
-    [DbContext(typeof(LibraryDbContext))]
-    partial class LibraryDbContextModelSnapshot : ModelSnapshot
-    {
-        protected override void BuildModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder.HasAnnotation("ProductVersion", "8.0.19");
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.CaptionEntity", b =>
-                {
-                    b.Property<string>("MediaId")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("LanguageCode")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("CreatedAtUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("LastModifiedUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.HasKey("MediaId", "LanguageCode");
-
-                    b.ToTable("captions", (string)null);
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.ChannelEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("CreatedAtUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Description")
-                        .HasMaxLength(500)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("JoinedDate")
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("LastModifiedUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Name")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("Subscribers")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<long>("TotalVideos")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<long>("TotalViews")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("channels", (string)null);
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.ClientAccountEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("CreatedAtUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("LastModifiedUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("UserAgent")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("client_accounts", (string)null);
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.HttpCookieEntity", b =>
-                {
-                    b.Property<string>("Name")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("ClientId")
-                        .IsRequired()
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("CreatedAtUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Domain")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTimeOffset?>("ExpiresUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<bool>("HttpOnly")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<DateTime>("LastModifiedUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Path")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("SameSite")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<bool>("Secure")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<string>("Value")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.HasKey("Name");
-
-                    b.HasIndex("ClientId");
-
-                    b.ToTable("http_cookies", (string)null);
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.Join.PlaylistMedia", b =>
-                {
-                    b.Property<string>("PlaylistId")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("MediaId")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("CreatedAtUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("LastModifiedUtc")
-                        .HasColumnType("TEXT");
-
-                    b.HasKey("PlaylistId", "MediaId");
-
-                    b.HasIndex("MediaId");
-
-                    b.ToTable("join_playlist_media", (string)null);
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.MediaEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("ChannelId")
-                        .IsRequired()
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("CreatedAtUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Description")
-                        .HasMaxLength(500)
-                        .HasColumnType("TEXT");
-
-                    b.Property<int>("ExternalState")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<bool>("IsDownloaded")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<DateTime>("LastModifiedUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<int>("State")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<string>("Title")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("UploadDateUtc")
-                        .HasColumnType("TEXT");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ChannelId");
-
-                    b.ToTable("media", (string)null);
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.MediaFormatEntity", b =>
-                {
-                    b.Property<string>("MediaId")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<int>("Itag")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<long>("ApproxDurationMs")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<int?>("AudioChannels")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<string>("AudioSampleRate")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("AverageBitrate")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<long>("Bitrate")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<long>("ContentLengthBytes")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<DateTime>("CreatedAtUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<double?>("Framerate")
-                        .HasColumnType("REAL");
-
-                    b.Property<int?>("Height")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<bool>("IsAdaptive")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<long>("LastModifiedUnixEpoch")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<DateTime>("LastModifiedUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<double?>("LoudnessDb")
-                        .HasColumnType("REAL");
-
-                    b.Property<string>("MimeType")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Quality")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("QualityLabel")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<int?>("Width")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("MediaId", "Itag");
-
-                    b.ToTable("media_formats", (string)null);
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.PlaylistEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("ChannelId")
-                        .IsRequired()
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("CreatedAtUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Description")
-                        .HasMaxLength(500)
-                        .HasColumnType("TEXT");
-
-                    b.Property<DateTime>("LastModifiedUtc")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasMaxLength(100)
-                        .HasColumnType("TEXT");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ChannelId");
-
-                    b.ToTable("playlists", (string)null);
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.CaptionEntity", b =>
-                {
-                    b.HasOne("Manager.Data.Entities.LibraryContext.MediaEntity", null)
-                        .WithMany("Captions")
-                        .HasForeignKey("MediaId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.ClientAccountEntity", b =>
-                {
-                    b.HasOne("Manager.Data.Entities.LibraryContext.ChannelEntity", null)
-                        .WithOne("ClientAccount")
-                        .HasForeignKey("Manager.Data.Entities.LibraryContext.ClientAccountEntity", "Id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.HttpCookieEntity", b =>
-                {
-                    b.HasOne("Manager.Data.Entities.LibraryContext.ClientAccountEntity", null)
-                        .WithMany("HttpCookies")
-                        .HasForeignKey("ClientId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.Join.PlaylistMedia", b =>
-                {
-                    b.HasOne("Manager.Data.Entities.LibraryContext.MediaEntity", null)
-                        .WithMany("PlaylistMedias")
-                        .HasForeignKey("MediaId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Manager.Data.Entities.LibraryContext.PlaylistEntity", null)
-                        .WithMany("PlaylistMedias")
-                        .HasForeignKey("PlaylistId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.MediaEntity", b =>
-                {
-                    b.HasOne("Manager.Data.Entities.LibraryContext.ChannelEntity", null)
-                        .WithMany("Media")
-                        .HasForeignKey("ChannelId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.MediaFormatEntity", b =>
-                {
-                    b.HasOne("Manager.Data.Entities.LibraryContext.MediaEntity", null)
-                        .WithMany("Formats")
-                        .HasForeignKey("MediaId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.PlaylistEntity", b =>
-                {
-                    b.HasOne("Manager.Data.Entities.LibraryContext.ChannelEntity", null)
-                        .WithMany("Playlists")
-                        .HasForeignKey("ChannelId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.ChannelEntity", b =>
-                {
-                    b.Navigation("ClientAccount");
-
-                    b.Navigation("Media");
-
-                    b.Navigation("Playlists");
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.ClientAccountEntity", b =>
-                {
-                    b.Navigation("HttpCookies");
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.MediaEntity", b =>
-                {
-                    b.Navigation("Captions");
-
-                    b.Navigation("Formats");
-
-                    b.Navigation("PlaylistMedias");
-                });
-
-            modelBuilder.Entity("Manager.Data.Entities.LibraryContext.PlaylistEntity", b =>
-                {
-                    b.Navigation("PlaylistMedias");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}
--- a/Manager.YouTube/Models/AdditionalJsonData.cs
+++ b/Manager.YouTube/Models/AdditionalJsonData.cs
@@ -0,0 +1,9 @@
+using System.Text.Json.Serialization;
+
+namespace Manager.YouTube.Models;
+
+public class AdditionalJsonData
+{
+    [JsonExtensionData]
+    public Dictionary<string, object> AdditionalData { get; set; } = [];
+}
--- a/Manager.YouTube/Models/Innertube/ClientState.cs
+++ b/Manager.YouTube/Models/Innertube/ClientState.cs
@@ -2,16 +2,41 @@ using System.Text.Json.Serialization;

 namespace Manager.YouTube.Models.Innertube;

-public class ClientState
+public class ClientState : AdditionalJsonData
 {
-    [JsonExtensionData]
-    public Dictionary<string, object> AdditionalData { get; set; } = [];
-
+    public bool IsPremiumUser { get; set; }
    [JsonPropertyName("INNERTUBE_API_KEY")]
    public string? InnertubeApiKey { get; set; }
+
+    [JsonPropertyName("LINK_API_KEY")]
+    public string? LinkApiKey { get; set; }
+    
+    [JsonPropertyName("VOZ_API_KEY")]
+    public string? VozApiKey { get; set; }
    
    [JsonPropertyName("SIGNIN_URL")]
    public string? SigninUrl { get; set; }
+    
+    [JsonPropertyName("INNERTUBE_CLIENT_NAME")]
+    public string? InnerTubeClient { get; set; }
+
+    [JsonPropertyName("INNERTUBE_CLIENT_VERSION")]
+    public string? InnerTubeClientVersion { get; set; }
+
+    [JsonPropertyName("LOGGED_IN")]
+    public bool LoggedIn { get; set; }
+
+    [JsonPropertyName("WEB_PLAYER_CONTEXT_CONFIGS")]
+    public WebPlayerContextConfig? WebPlayerContextConfig { get; set; }
+    
+    [JsonPropertyName("USER_ACCOUNT_NAME")]
+    public string? UserAccountName { get; set; }
+
+    [JsonPropertyName("SERVER_VERSION")]
+    public string? ServerVersion { get; set; }
+
+    [JsonPropertyName("INNERTUBE_CONTEXT")]
+    public InnerTubeContext? InnerTubeContext { get; set; }

    [JsonPropertyName("SBOX_SETTINGS")]
    public SBoxSettings? SBoxSettings { get; set; }
--- a/Manager.YouTube/Models/Innertube/InnerTubeClient.cs
+++ b/Manager.YouTube/Models/Innertube/InnerTubeClient.cs
@@ -0,0 +1,15 @@
+using System.Text.Json.Serialization;
+
+namespace Manager.YouTube.Models.Innertube;
+
+public class InnerTubeClient : AdditionalJsonData
+{
+    [JsonPropertyName("hl")]
+    public string? HLanguage { get; set; }
+    [JsonPropertyName("gl")]
+    public string? GLanguage { get; set; }
+    [JsonPropertyName("remoteHost")]
+    public string? RemoteHost { get; set; }
+    [JsonPropertyName("rolloutToken")]
+    public string? RolloutToken { get; set; }
+}
--- a/Manager.YouTube/Models/Innertube/InnerTubeContext.cs
+++ b/Manager.YouTube/Models/Innertube/InnerTubeContext.cs
@@ -0,0 +1,9 @@
+using System.Text.Json.Serialization;
+
+namespace Manager.YouTube.Models.Innertube;
+
+public class InnerTubeContext : AdditionalJsonData
+{
+    [JsonPropertyName("client")]
+    public InnerTubeClient? InnerTubeClient { get; set; }
+}
--- a/Manager.YouTube/Models/Innertube/InnertubeChannel.cs
+++ b/Manager.YouTube/Models/Innertube/InnertubeChannel.cs
@@ -0,0 +1,15 @@
+namespace Manager.YouTube.Models.Innertube;
+
+public class InnertubeChannel
+{
+    public required string Id { get; set; }
+    public bool NoIndex { get; set; }
+    public bool Unlisted { get; set; }
+    public bool FamilySafe { get; set; }
+    public string? ChannelName { get; set; }
+    public string? Handle { get; set; }
+    public string? Description { get; set; }
+    public List<string> AvailableCountries { get; set; } = [];
+    public List<WebImage> AvatarImages { get; set; } = [];
+    public List<WebImage> BannerImages { get; set; } = [];
+}
--- a/Manager.YouTube/Models/Innertube/WebImage.cs
+++ b/Manager.YouTube/Models/Innertube/WebImage.cs
@@ -0,0 +1,8 @@
+namespace Manager.YouTube.Models.Innertube;
+
+public class WebImage
+{
+    public int Width { get; set; }
+    public int Height { get; set; }
+    public string Url { get; set; } = "";
+}
--- a/Manager.YouTube/Models/Innertube/WebPlayerContext.cs
+++ b/Manager.YouTube/Models/Innertube/WebPlayerContext.cs
@@ -0,0 +1,9 @@
+using System.Text.Json.Serialization;
+
+namespace Manager.YouTube.Models.Innertube;
+
+public class WebPlayerContext : AdditionalJsonData
+{
+    [JsonPropertyName("datasyncId")]
+    public string? DatasyncId { get; set; }
+}
--- a/Manager.YouTube/Models/Innertube/WebPlayerContextConfig.cs
+++ b/Manager.YouTube/Models/Innertube/WebPlayerContextConfig.cs
@@ -0,0 +1,9 @@
+using System.Text.Json.Serialization;
+
+namespace Manager.YouTube.Models.Innertube;
+
+public class WebPlayerContextConfig : AdditionalJsonData
+{
+    [JsonPropertyName("WEB_PLAYER_CONTEXT_CONFIG_ID_KEVLAR_WATCH")]
+    public WebPlayerContext? WebPlayerContext { get; set; }
+}
--- a/Manager.YouTube/NetworkService.cs
+++ b/Manager.YouTube/NetworkService.cs
@@ -1,59 +1,57 @@
-using System.Text.Json;
 using DotBased.Monads;
-using Manager.YouTube.Models.Innertube;
-using Manager.YouTube.Parsers;
 using Manager.YouTube.Util;

 namespace Manager.YouTube;

 public static class NetworkService
 {
-    public static async Task<Result<ClientState>> GetClientStateAsync(YouTubeClient client)
+    public const string Origin = "https://www.youtube.com";
+    private static readonly HttpClient HttpClient = new();
+
+    public static async Task<Result<string>> MakeRequestAsync(HttpRequestMessage request, YouTubeClient client, bool skipAuthenticationHeader = false)
    {
-        var origin = "https://www.youtube.com/";
-        var httpRequest = new HttpRequestMessage
+        request.Headers.Add("Origin", Origin);
+        request.Headers.UserAgent.ParseAdd(client.UserAgent);
+        if (client.SapisidCookie != null && !skipAuthenticationHeader)
        {
-            Method = HttpMethod.Get,
-            RequestUri = new Uri(origin)
-        };
-        httpRequest.Headers.IfModifiedSince = new DateTimeOffset(DateTime.UtcNow);
-        httpRequest.Headers.UserAgent.ParseAdd(client.UserAgent);
-        
-        if (client.SapisidCookie != null)
-        {
-            httpRequest.Headers.Authorization = AuthenticationUtilities.GetSapisidHashHeader(client.SapisidCookie.Value, origin);
-            httpRequest.Headers.Add("Origin", origin);
-        }
-        
-        var http = client.GetHttpClient();
-        if (http == null)
-        {
-            return ResultError.Fail("Unable to get http client!");
-        }
-        
-        var response = await http.SendAsync(httpRequest);
-        if (!response.IsSuccessStatusCode)
-        {
-            var responseResult = await response.Content.ReadAsStringAsync();
-            return Result<ClientState>.Fail(ResultError.Fail(responseResult));
-        }
-        var responseHtml = await response.Content.ReadAsStringAsync();
-        var clientStateResult = HtmlParser.GetJsonFromScriptFunction(responseHtml, "ytcfg.set");
-        if (clientStateResult is { IsSuccess: false, Error: not null })
-        {
-            return clientStateResult.Error;
+            request.Headers.Authorization = AuthenticationUtilities.GetSapisidHashHeader(client.GetDatasyncId(), client.SapisidCookie.Value, Origin);
        }

-        ClientState? clientState;
        try
        {
-            clientState = JsonSerializer.Deserialize<ClientState>(clientStateResult.Value);
+            var response = await client.HttpClient.SendAsync(request);
+            var contentString = await response.Content.ReadAsStringAsync();
+            if (!response.IsSuccessStatusCode)
+            {
+                return ResultError.Fail(contentString);
+            }
+            return contentString;
        }
        catch (Exception e)
        {
-            return ResultError.Error(e, "Error while parsing JSON!");
+            return ResultError.Error(e);
        }
-        
-        return clientState == null ? ResultError.Fail("Unable to parse client state!") : clientState;
    }
-}
+
+    public static async Task<Result<DownloadResult>> DownloadBytesAsync(HttpRequestMessage request, YouTubeClient? client = null)
+    {
+        try
+        {
+            var response = client != null ? await client.HttpClient.SendAsync(request) : await HttpClient.SendAsync(request);
+            if (!response.IsSuccessStatusCode)
+            {
+                return ResultError.Fail($"Failed to get file to download, response code: {response.StatusCode}.");
+            }
+            
+            var data = await response.Content.ReadAsByteArrayAsync();
+            
+            return new DownloadResult(data, response.Content.Headers.ContentType?.MediaType, response.Content.Headers.ContentDisposition?.FileName?.Trim('"'), response.Content.Headers.ContentLength ?? 0);
+        }
+        catch (Exception e)
+        {
+            return ResultError.Error(e);
+        }
+    }
+}
+
+public record DownloadResult(byte[] Data, string? ContentType, string? FileName, long ContentLength);
--- a/Manager.YouTube/Parsers/HtmlParser.cs
+++ b/Manager.YouTube/Parsers/HtmlParser.cs
@@ -1,4 +1,3 @@
-using System.Text.RegularExpressions;
 using DotBased.Monads;
 using HtmlAgilityPack;

@@ -6,34 +5,61 @@ namespace Manager.YouTube.Parsers;

 public static class HtmlParser
 {
-    public static Result<string> GetJsonFromScriptFunction(string html, string functionName)
+    public static Result<(string, bool)> GetStateJson(string html)
    {
        if (string.IsNullOrWhiteSpace(html))
        {
            return ResultError.Fail("html cannot be empty!");
        }
-        
-        if (string.IsNullOrWhiteSpace(functionName))
-        {
-            return ResultError.Fail("No function names provided!");
-        }

        var htmlDocument = new HtmlDocument();
        htmlDocument.LoadHtml(html);
-        
-        var scriptNode = htmlDocument.DocumentNode.SelectSingleNode($"//script[contains(., '{functionName}')]");
-        if (string.IsNullOrWhiteSpace(scriptNode.InnerText))
-            return ResultError.Fail($"Could not find {functionName} in html script nodes!");
-        
-        var regexPattern = $@"{Regex.Escape(functionName)}\(([^)]+)\);";
-        var match = Regex.Match(scriptNode.InnerText, regexPattern);

-        if (match.Success)
+        const string setFunction = "ytcfg.set({";
+        var scriptNode = htmlDocument.DocumentNode.SelectSingleNode($"//script[contains(., '{setFunction}')]");
+        if (string.IsNullOrWhiteSpace(scriptNode.InnerText))
+            return ResultError.Fail($"Could not find {setFunction} in html script nodes!");
+        
+        var json = ExtractJson(scriptNode.InnerText, "ytcfg.set(");
+
+        if (string.IsNullOrWhiteSpace(json))
        {
-            var jsonString = match.Groups[1].Value.Trim();
-            return jsonString;
+            return ResultError.Fail($"Could not find {setFunction} in html script nodes!");
        }

-        return ResultError.Fail($"Unable to parse {functionName} JSON!");
+        var isPremiumUser = html.Contains("logo-type=\"YOUTUBE_PREMIUM_LOGO\"", StringComparison.OrdinalIgnoreCase);
+
+        return (json, isPremiumUser);
+    }
+    
+    static string? ExtractJson(string input, string marker)
+    {
+        var start = input.IndexOf(marker, StringComparison.Ordinal);
+        if (start < 0) return null;
+
+        start += marker.Length;
+
+        // Skip until first '{'
+        while (start < input.Length && input[start] != '{')
+            start++;
+
+        if (start >= input.Length) return null;
+
+        var depth = 0;
+        var i = start;
+
+        for (; i < input.Length; i++)
+        {
+            if (input[i] == '{') depth++;
+            else if (input[i] == '}')
+            {
+                depth--;
+                if (depth != 0) continue;
+                i++;
+                break;
+            }
+        }
+
+        return input[start..i];
    }
 }
--- a/Manager.YouTube/Parsers/Json/ChannelJsonParser.cs
+++ b/Manager.YouTube/Parsers/Json/ChannelJsonParser.cs
@@ -0,0 +1,83 @@
+using System.Text.Json;
+using DotBased.Monads;
+using Manager.YouTube.Models.Innertube;
+
+namespace Manager.YouTube.Parsers.Json;
+
+public static class ChannelJsonParser
+{
+    public static Result<InnertubeChannel> ParseJsonToChannelData(string json)
+    {
+        try
+        {
+            var doc = JsonDocument.Parse(json);
+            var rootDoc = doc.RootElement;
+            
+            var channelMetadata = rootDoc
+                .GetProperty("metadata")
+                .GetProperty("channelMetadataRenderer");
+
+            var channelId = channelMetadata.GetProperty("externalId").GetString();
+            if (channelId == null)
+            {
+                throw new InvalidOperationException("No channel id found.");
+            }
+
+            var channel = new InnertubeChannel
+            {
+                Id = channelId,
+                ChannelName = channelMetadata.GetProperty("title").ToString(),
+            };
+
+            var microformat = rootDoc.GetProperty("microformat").GetProperty("microformatDataRenderer");
+
+            channel.AvailableCountries = microformat
+                .GetProperty("availableCountries")
+                .EnumerateArray()
+                .Select(e => e.GetString())
+                .OfType<string>().ToList();
+            channel.Description = microformat.GetProperty("description").GetString();
+            channel.NoIndex = microformat.GetProperty("noindex").GetBoolean();
+            channel.Unlisted = microformat.GetProperty("unlisted").GetBoolean();
+            channel.FamilySafe = microformat.GetProperty("familySafe").GetBoolean();
+            
+            var avatarThumbnails = channelMetadata.GetProperty("avatar")
+                .GetProperty("thumbnails")
+                .EnumerateArray();
+            channel.AvatarImages = JsonParser.ParseImages(avatarThumbnails);
+
+            var headerContent = rootDoc
+                .GetProperty("header")
+                .GetProperty("pageHeaderRenderer")
+                .GetProperty("content");
+
+            channel.Handle = headerContent
+                .GetProperty("pageHeaderViewModel")
+                .GetProperty("metadata")
+                .GetProperty("contentMetadataViewModel")
+                .GetProperty("metadataRows")
+                .EnumerateArray()
+                .FirstOrDefault()
+                .GetProperty("metadataParts")
+                .EnumerateArray()
+                .FirstOrDefault()
+                .GetProperty("text")
+                .GetProperty("content").GetString();
+
+            var bannerImages = headerContent
+                .GetProperty("pageHeaderViewModel")
+                .GetProperty("banner")
+                .GetProperty("imageBannerViewModel")
+                .GetProperty("image")
+                .GetProperty("sources")
+                .EnumerateArray();
+            channel.BannerImages = JsonParser.ParseImages(bannerImages);
+            
+            return channel;
+        }
+        catch (Exception e)
+        {
+            return ResultError.Error(e);
+        }
+    }
+}
--- a/Manager.YouTube/Parsers/Json/JsonAccountParser.cs
+++ b/Manager.YouTube/Parsers/Json/JsonAccountParser.cs
@@ -0,0 +1,43 @@
+using System.Text.Json;
+using DotBased.Monads;
+
+namespace Manager.YouTube.Parsers.Json;
+
+/// <summary>
+/// Parsing functionality for the response from endpoint: /youtubei/v1/account/account_menu
+/// </summary>
+public static class JsonAccountParser
+{
+    public static Result<string> ParseAccountId(string json)
+    {
+        try
+        {
+            var jsonDocument = JsonDocument.Parse(json);
+
+            var id = jsonDocument.RootElement
+                .GetProperty("actions")[0]
+                .GetProperty("openPopupAction")
+                .GetProperty("popup")
+                .GetProperty("multiPageMenuRenderer")
+                .GetProperty("header")
+                .GetProperty("activeAccountHeaderRenderer")
+                .GetProperty("manageAccountTitle")
+                .GetProperty("runs")
+                .EnumerateArray()
+                .FirstOrDefault()
+                .GetProperty("navigationEndpoint")
+                .GetProperty("browseEndpoint")
+                .GetProperty("browseId").GetString();
+            
+            if (string.IsNullOrWhiteSpace(id))
+            {
+                return ResultError.Fail("Unable to get account id!");
+            }
+            return id;
+        }
+        catch (Exception e)
+        {
+            return ResultError.Error(e);
+        }
+    }
+}
--- a/Manager.YouTube/Parsers/Json/JsonParser.cs
+++ b/Manager.YouTube/Parsers/Json/JsonParser.cs
@@ -0,0 +1,12 @@
+using System.Text.Json;
+using Manager.YouTube.Models.Innertube;
+
+namespace Manager.YouTube.Parsers.Json;
+
+public static class JsonParser
+{
+    public static List<WebImage> ParseImages(JsonElement.ArrayEnumerator array) =>
+        array
+            .Select(image => new WebImage { Width = image.GetProperty("width").GetInt32(), Height = image.GetProperty("height").GetInt32(), Url = image.GetProperty("url").GetString() ?? "" })
+            .ToList();
+}
--- a/Manager.YouTube/Util/AuthenticationUtilities.cs
+++ b/Manager.YouTube/Util/AuthenticationUtilities.cs
@@ -9,17 +9,39 @@ public static class AuthenticationUtilities
 {
    private const string HeaderScheme = "SAPISIDHASH";
    
-    // Dave Thomas @ https://stackoverflow.com/a/32065323/9948300
-    public static AuthenticationHeaderValue? GetSapisidHashHeader(string sapisid, string origin)
+    // Dave Thomas & windy for updated answer @ https://stackoverflow.com/a/32065323/9948300
+    public static AuthenticationHeaderValue GetSapisidHashHeader(string datasyncId, string sapisid, string origin)
    {
-        if (string.IsNullOrWhiteSpace(sapisid) || string.IsNullOrWhiteSpace(origin))
-            return null;
-        var time = GetTime();
-        var sha1 = HashString($"{time} {sapisid} {origin}");
-        var completeHash = $"{time}_{sha1}";
-        return new AuthenticationHeaderValue(HeaderScheme, completeHash);
+        var strHash = GetSapisidHash(datasyncId, sapisid, origin);
+        return new AuthenticationHeaderValue(HeaderScheme, strHash);
    }
-    
+
+    public static string GetSapisidHash(string datasyncId, string sapisid, string origin, string? time = null)
+    {
+        if (string.IsNullOrWhiteSpace(datasyncId))
+        {
+            throw new ArgumentNullException(nameof(datasyncId));
+        }
+        if (string.IsNullOrWhiteSpace(sapisid))
+        {
+            throw new ArgumentNullException(nameof(sapisid));
+        }
+        if (string.IsNullOrWhiteSpace(origin))
+        {
+            throw new ArgumentNullException(nameof(origin));
+        }
+        
+        datasyncId = datasyncId.Replace("||", "");
+        sapisid = Uri.UnescapeDataString(sapisid);
+        if (string.IsNullOrWhiteSpace(time))
+        {
+            time = GetTime();
+        }
+        var sha1 = HashString($"{datasyncId} {time} {sapisid} {origin}");
+        var completeHash = $"{time}_{sha1}_u";
+        return completeHash;
+    }
+
    private static string HashString(string stringData)
    {
        var dataBytes = Encoding.ASCII.GetBytes(stringData);
--- a/Manager.YouTube/YouTubeClient.cs
+++ b/Manager.YouTube/YouTubeClient.cs
@@ -1,59 +1,264 @@
 using System.Net;
-using DotBased.Logging;
+using System.Net.Mime;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using DotBased.Monads;
 using Manager.YouTube.Models.Innertube;
+using Manager.YouTube.Parsers;
+using Manager.YouTube.Parsers.Json;

 namespace Manager.YouTube;

 public sealed class YouTubeClient : IDisposable
 {
-    public string Id { get; private set; }
-    public string AccountName { get; private set; }
-    public string? UserAgent { get; private set; }
-    public CookieContainer CookieContainer { get; }
-    public ClientState? ClientState { get; private set; }
+    public string Id { get; private set; } = "";
+    public string? UserAgent { get; set; }
+    public bool IsAnonymous { get; }
+    public CookieContainer CookieContainer { get; } = new() { PerDomainCapacity = 50 };
+    public ClientState? State { get; private set; }
+    public List<string> DatasyncIds { get; } = [];
    public Cookie? SapisidCookie => CookieContainer.GetAllCookies()["SAPISID"];
-    public HttpClient? GetHttpClient() => _httpClient;
-
-    private readonly ILogger? _logger;
-    private HttpClient? _httpClient;
-
-    public YouTubeClient(CookieContainer cookieContainer, string userAgent, ILogger? logger = null)
+    public HttpClient HttpClient { get; }
+    
+    private YouTubeClient(CookieCollection cookies, string userAgent)
    {
-        CookieContainer = cookieContainer;
-        _logger = logger;
+        if (string.IsNullOrWhiteSpace(userAgent))
+        {
+            throw new ArgumentNullException(nameof(userAgent));
+        }
        UserAgent = userAgent;
-        SetupClient();
+        if (cookies.Count == 0)
+        {
+            Id = $"anon_{Guid.NewGuid()}";
+            IsAnonymous = true;
+        }
+
+        CookieContainer.Add(cookies);
+        HttpClient = new HttpClient(GetHttpClientHandler());
    }

-    private void SetupClient()
+    /// <summary>
+    /// Loads the given cookies and fetch client state.
+    /// </summary>
+    /// <param name="cookies">The cookies to use for making requests. Empty collection for anonymous requests.</param>
+    /// <param name="userAgent">The user agent to use for the requests. Only WEB client is supported.</param>
+    /// <returns></returns>
+    public static async Task<Result<YouTubeClient>> CreateAsync(CookieCollection cookies, string userAgent)
    {
-        _logger?.Information("Building http client...");
-        _httpClient?.Dispose();
+        var client = new YouTubeClient(cookies, userAgent);
+        var clientInitializeResult = await client.FetchClientDataAsync();
+        if (!clientInitializeResult.IsSuccess)
+        {
+            return clientInitializeResult.Error ?? ResultError.Fail("Failed to initialize YouTube client!");
+        }

+        return client;
+    }
+
+    private HttpClientHandler GetHttpClientHandler()
+    {
        var clientHandler = new HttpClientHandler
        {
            AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip,
            UseCookies = true,
            CookieContainer = CookieContainer
        };
-        _httpClient = new HttpClient(clientHandler);
+        return clientHandler;
    }

-    public async Task GetStateAsync()
+    internal async Task<Result> FetchClientDataAsync()
    {
-        var state = await NetworkService.GetClientStateAsync(this);
-        if (!state.IsSuccess)
+        if (State is not { LoggedIn: true })
        {
-            _logger?.Warning("Error getting client state: {StateError}", state.Error);
-            return;
+            var state = await GetClientStateAsync();
+            if (!state.IsSuccess)
+            {
+                return state;
+            }
        }
+
+        if (string.IsNullOrWhiteSpace(State?.WebPlayerContextConfig?.WebPlayerContext?.DatasyncId))
+        {
+            var datasyncResult = await GetDatasyncIds();
+            if (!datasyncResult.IsSuccess)
+            {
+                return datasyncResult;
+            }
+
+            foreach (var id in datasyncResult.Value)
+            {
+                if (DatasyncIds.Contains(id))
+                    continue;
+                DatasyncIds.Add(id);
+            }
+        }
+
+        if (string.IsNullOrWhiteSpace(Id))
+        {
+            var accountInfoResult = await GetCurrentAccountIdAsync();
+            if (!accountInfoResult.IsSuccess)
+            {
+                return accountInfoResult;
+            }
+
+            Id = accountInfoResult.Value;
+        }
+
+        return Result.Success();
+    }
+    
+    private async Task<Result> GetClientStateAsync()
+    {
+        var httpRequest = new HttpRequestMessage
+        {
+            Method = HttpMethod.Get,
+            RequestUri = new Uri(NetworkService.Origin)
+        };
        
-        ClientState = state.Value;
-        _logger?.Information("Client state retrieved. With API key: {InnertubeApiKey}", ClientState.InnertubeApiKey);
+        var result = await NetworkService.MakeRequestAsync(httpRequest, this, true);
+        if (!result.IsSuccess)
+        {
+            return result.Error ?? ResultError.Fail("Request failed!");
+        }
+
+        var clientStateResult = HtmlParser.GetStateJson(result.Value);
+        if (clientStateResult is { IsSuccess: false, Error: not null })
+        {
+            return clientStateResult.Error;
+        }
+
+        try
+        {
+            State = JsonSerializer.Deserialize<ClientState>(clientStateResult.Value.Item1);
+        }
+        catch (Exception e)
+        {
+            return ResultError.Error(e, "Error while parsing JSON!");
+        }
+
+
+        if (State == null)
+        {
+            return ResultError.Fail("Unable to parse client state!");
+        }
+
+        State.IsPremiumUser = clientStateResult.Value.Item2;
+        
+        return Result.Success();
+    }
+    
+    public async Task<Result<InnertubeChannel>> GetChannelByIdAsync(string channelId)
+    {
+        if (State == null)
+        {
+            return ResultError.Fail("No client state!");
+        }
+
+        if (string.IsNullOrWhiteSpace(channelId))
+        {
+            return ResultError.Fail("Channel id is empty!");
+        }
+
+        var serializedContext = JsonSerializer.SerializeToNode(State.InnerTubeContext);
+        var payload = new JsonObject { { "context", serializedContext }, { "browseId", channelId } };
+        var requestMessage = new HttpRequestMessage
+        {
+            Method = HttpMethod.Post,
+            RequestUri = new Uri($"{NetworkService.Origin}/youtubei/v1/browse?key={State.InnertubeApiKey}"),
+            Content = new StringContent(payload.ToJsonString(), Encoding.UTF8, MediaTypeNames.Application.Json)
+        };
+        var responseResult = await NetworkService.MakeRequestAsync(requestMessage, this);
+        if (!responseResult.IsSuccess)
+        {
+            return responseResult.Error ?? ResultError.Fail("Request failed!");
+        }
+
+        return ChannelJsonParser.ParseJsonToChannelData(responseResult.Value);
+    }
+
+    public string GetDatasyncId()
+    {
+        if (!string.IsNullOrWhiteSpace(State?.WebPlayerContextConfig?.WebPlayerContext?.DatasyncId))
+        {
+            return State.WebPlayerContextConfig.WebPlayerContext.DatasyncId;
+        }
+
+        var tempDatasyncId = "";
+        foreach (var datasyncId in DatasyncIds)
+        {
+            var split = datasyncId.Split("||", StringSplitOptions.RemoveEmptyEntries);
+            switch (split.Length)
+            {
+                case 0:
+                case 2 when tempDatasyncId.Equals(split[1]):
+                    continue;
+                case 2:
+                    tempDatasyncId = split[1];
+                    break;
+            }
+        }
+
+        return tempDatasyncId;
    }

    public void Dispose()
    {
-        _httpClient?.Dispose();
+        HttpClient.Dispose();
+    }
+    
+    private async Task<Result<string>> GetCurrentAccountIdAsync()
+    {
+        if (State is not { LoggedIn: true })
+        {
+            return ResultError.Fail("Client not logged in!");
+        }
+
+        var httpRequest = new HttpRequestMessage
+        {
+            Method = HttpMethod.Post,
+            RequestUri = new Uri($"{NetworkService.Origin}/youtubei/v1/account/account_menu")
+        };
+        var serializedContext = JsonSerializer.SerializeToNode(State.InnerTubeContext);
+        var payload = new JsonObject { { "context", serializedContext } };
+        httpRequest.Content = new StringContent(payload.ToJsonString(), Encoding.UTF8, MediaTypeNames.Application.Json);
+        var responseResult = await NetworkService.MakeRequestAsync(httpRequest, this);
+
+        if (!responseResult.IsSuccess)
+        {
+            return responseResult.Error ?? ResultError.Fail("Request failed!");
+        }
+        
+        return JsonAccountParser.ParseAccountId(responseResult.Value);
+    }
+    
+    private async Task<Result<string[]>> GetDatasyncIds()
+    {
+        if (State is not { LoggedIn: true } || CookieContainer.Count == 0)
+        {
+            return ResultError.Fail("Client is not logged in, requires logged in client for this endpoint (/getDatasyncIdsEndpoint).");
+        }
+
+        var httpRequest = new HttpRequestMessage
+        {
+            Method = HttpMethod.Get,
+            RequestUri = new Uri($"{NetworkService.Origin}/getDatasyncIdsEndpoint")
+        };
+        var responseResult = await NetworkService.MakeRequestAsync(httpRequest, this);
+        if (!responseResult.IsSuccess)
+        {
+            return responseResult.Error ?? ResultError.Fail("Request failed!");
+        }
+        
+        var datasyncIdsJson = JsonNode.Parse(responseResult.Value.Replace(")]}'", ""));
+
+        var isLoggedOut = datasyncIdsJson?["responseContext"]?["mainAppWebResponseContext"]?["loggedOut"]
+            .Deserialize<bool>() ?? true;
+        if (!isLoggedOut)
+        {
+            return datasyncIdsJson?["datasyncIds"].Deserialize<string[]>() ?? [];
+        }
+
+        return ResultError.Fail("Failed to get datasyncIds! Client not logged in.");
    }
 }
--- a/Manager.YouTube/YouTubeClientCollection.cs
+++ b/Manager.YouTube/YouTubeClientCollection.cs
@@ -0,0 +1,11 @@
+using System.Collections.ObjectModel;
+
+namespace Manager.YouTube;
+
+public class YouTubeClientCollection : KeyedCollection<string, YouTubeClient>
+{
+    protected override string GetKeyForItem(YouTubeClient item)
+    {
+        return item.Id;
+    }
+}
--- a/Manager.YouTube/YouTubeService.cs
+++ b/Manager.YouTube/YouTubeService.cs
@@ -1,6 +0,0 @@
-namespace Manager.YouTube;
-
-public class YouTubeService()
-{
-    
-}
Author	SHA1	Message	Date
max	79ea2badf1	[FIX] EventConsole batch fix	2025-09-18 02:10:13 +02:00
max	5250b9f3f9	[REWORK] Changes saving client and channel info	2025-09-18 02:01:45 +02:00
max	9e173258ed	[CHANGES]	2025-09-18 00:42:17 +02:00
max	ab532ac6dc	[CHANGE] Fixed cache service && Download channel images from cache	2025-09-18 00:30:35 +02:00
max	8a64d6fc64	[CHANGE] Remove anon accounts && added simple caching for urls	2025-09-17 23:44:02 +02:00
max	0056a14f79	[CHANGE] Fixed auditing, storing images from account import	2025-09-15 00:23:57 +02:00
max	e82736a45f	[CHANGE] History -> Audit	2025-09-14 03:30:39 +02:00
max	0f83cf1ddc	[CHANGE] Reworked db with interceptors	2025-09-10 23:49:41 +02:00
max	b1e5b0dc68	[CHANGE] event console own component	2025-09-10 20:09:58 +02:00
max	9be6f5be89	[CHANGE] Reworked event console	2025-09-10 18:19:36 +02:00
max	ef6ca0ee07	[OPTIMIZING]	2025-09-10 02:55:06 +02:00
max	03631cd0c8	[CHANGE] Service extended and events	2025-09-10 01:46:07 +02:00
max	9ff4fcded2	[CHANGE] Services view	2025-09-09 19:51:07 +02:00
max	2593d02a73	[CHANGE] BackgroundServices	2025-09-09 19:11:02 +02:00
max	d183803390	[CHANGE] DI fixes	2025-09-09 00:58:12 +02:00
max	a5e55e563e	[CHANGE] Small fixes	2025-09-08 21:56:42 +02:00
max	b3861b7cd9	[CHANGE] Get username from other json property	2025-09-08 21:40:54 +02:00
max	680b6d2cc9	[CHANGE] Reworked client creation	2025-09-08 21:28:33 +02:00
max	b2c9fc2c52	[CHANGE] Finished impl required data for client	2025-09-08 01:40:43 +02:00
max	b2c6003203	[CHANGE] Split up json parsing, added getting account info	2025-09-07 22:18:56 +02:00
max	3db61b599d	[CHANGE] GetChannel impl	2025-09-07 01:24:46 +02:00
max	c528ad9bb3	[CHANGE] Rework && adding channel fetching	2025-09-06 20:40:46 +02:00
max	d0eca248bb	[CHANGE] Cleanup cookie import	2025-09-06 03:10:20 +02:00
max	fa0c617c9a	[CHANGE] Get all account info	2025-09-06 01:07:12 +02:00
max	f334c87fbb	[CHANGE] Cookie login fixed	2025-09-05 23:36:51 +02:00
max	55322f8792	[CHANGE] Added dev page	2025-09-05 16:23:32 +02:00
max	92e5bb7f1f	[CHANGE] Working on auth hash	2025-09-04 20:32:39 +02:00
max	431a103fac	[CHANGE] Add account dialog	2025-09-04 18:05:56 +02:00
max	a8cfbbe0db	[CHANGE] Adding accounts	2025-09-04 10:37:38 +02:00
max	f7bfee5de2	[CHANGE] Accounts to Channels, update navmenu	2025-09-04 08:48:06 +02:00