feat(app): library, jobs, settings, server, welcome and about screens

Local-mode composition root (SQLite index, one JobEngine fed by a single
handler registration list), keyset-paged library with thumbnail cache and
hover scrub, live job list with throttled updates and the shell job bar,
settings with live template validation and encoder self-test, server
connection with trust-on-first-use and DPAPI token, first-run welcome,
About with update check, and --capture screenshots with synthetic data.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
This commit is contained in:
Claude committed 2026-10-02 12:26:58 +00:00
1 parent 446daeae2b
commit ffbea7cb74
94 files changed
+10130 -374

No files matched your search

+238
View File
@@ -0,0 +1,238 @@
using System.Collections.ObjectModel;
using Titano.App.Infrastructure;
using Titano.Core.Diagnostics;
using Titano.Core.Localization;
using Titano.Protocol;
using Titano.Ui.Mvvm;
namespace Titano.App.Server;
/// <summary>
/// The client's server connection (BRIEF §12.7): drives <see cref="ConnectFlow"/> with the dialogs (fingerprint
/// confirmation before any password is sent, login form), keeps the session token encrypted with DPAPI in the
/// settings, restores it at start, and lists servers announced on the LAN. Runs on the UI thread.
/// </summary>
public sealed class ServerSession : ObservableObject, ITrustStore, IDisposable
{
private readonly AppSettings _settings;
private readonly Action _save;
private readonly ITokenProtector _protector;
private readonly ConnectFlow _flow;
private DiscoveryListener? _discovery;
private bool _busy;
public ServerSession(AppSettings settings, Action save, IServerApiFactory factory, ITokenProtector protector)
{
_settings = settings;
_save = save;
_protector = protector;
_flow = new ConnectFlow(factory, this);
_flow.Changed += (_, _) => OnAllPropertiesChanged();
}
public ConnectFlow Flow => _flow;
/// <summary>Servers that announced themselves on this network.</summary>
public ObservableCollection<DiscoveredServer> Discovered { get; } = [];
public bool IsConnected => _flow.Step == ConnectStep.Connected;
/// <summary>A connection attempt is running.</summary>
public bool IsBusy
{
get => _busy;
private set => Set(ref _busy, value);
}
/// <summary>Server name for the status strip; null when not connected.</summary>
public string? ServerName => IsConnected ? _flow.Info?.Name : null;
/// <summary>The saved address (last server used).</summary>
public string? SavedAddress => _settings.ServerUrl;
/// <summary>The token of the saved session is present (Disconnect keeps it).</summary>
public bool HasSavedSession => _settings.ServerUrl is not null && _settings.ProtectedToken is not null;
// ---------------- ITrustStore ----------------
public IReadOnlyCollection<string> Fingerprints => [.. _settings.TrustedCertificates.Select(c => c.Fingerprint)];
public void Trust(string server, string fingerprint)
{
if (_settings.TrustedCertificates.Any(c => c.Fingerprint.Equals(fingerprint, StringComparison.OrdinalIgnoreCase))) return;
_settings.TrustedCertificates.Add(new TrustedCertificate { Fingerprint = fingerprint, Server = server, TrustedAt = DateTimeOffset.UtcNow });
_save();
Log.Info("server", $"Trusted certificate {fingerprint} of {server}");
}
/// <summary>The trust record of a fingerprint, if the user trusted it.</summary>
public TrustedCertificate? TrustOf(string? fingerprint) =>
fingerprint is null ? null : _settings.TrustedCertificates.FirstOrDefault(c => c.Fingerprint.Equals(fingerprint, StringComparison.OrdinalIgnoreCase));
/// <summary>Forgets a trusted certificate; the next connection asks again.</summary>
public void Forget(string fingerprint)
{
if (_settings.TrustedCertificates.RemoveAll(c => c.Fingerprint.Equals(fingerprint, StringComparison.OrdinalIgnoreCase)) == 0) return;
_save();
OnAllPropertiesChanged();
}
// ---------------- Session ----------------
/// <summary>Resumes the saved session at start; stays signed out quietly when it cannot be reused.</summary>
public async Task RestoreAsync(CancellationToken ct = default)
{
if (_settings.ServerUrl is not { } address || _settings.ProtectedToken is not { } blob) return;
var token = _protector.Unprotect(blob);
if (token is null)
{
Log.Warning("server", "The saved session cannot be decrypted; sign in again");
ForgetToken();
return;
}
IsBusy = true;
try
{
var step = await _flow.RestoreAsync(address, token, ct);
if (step == ConnectStep.Connected) Log.Info("server", $"Session restored on {address}");
else if (_flow.Error is ConnectError.SessionExpired or ConnectError.CertificateChanged) ForgetToken();
}
finally
{
IsBusy = false;
}
}
/// <summary>
/// Connects to <paramref name="address"/>: identifies the server, asks to trust an unknown self-signed
/// certificate, then reuses the saved session or shows the login form. True when connected.
/// </summary>
public async Task<bool> ConnectAsync(string address, IAppDialogs dialogs, CancellationToken ct = default)
{
IsBusy = true;
try
{
var step = await _flow.ProbeAsync(address, ct);
if (step == ConnectStep.AwaitingTrust && _flow.PendingFingerprint is { } fingerprint)
{
var trusted = dialogs.Confirm(TrustRequest(ServerAddress.Display(_flow.Address!), fingerprint));
step = await _flow.ConfirmTrustAsync(trusted, ct);
}
if (step != ConnectStep.AwaitingCredentials) return false;
var display = ServerAddress.Display(_flow.Address!);
if (HasSavedSession && ServerAddress.Display(_settings.ServerUrl) == display && _protector.Unprotect(_settings.ProtectedToken!) is { } token)
{
step = await _flow.RestoreAsync(display, token, ct);
if (step == ConnectStep.Connected)
{
Remember();
return true;
}
if (step != ConnectStep.AwaitingCredentials) return false;
}
var signedIn = dialogs.SignIn(display, _settings.ServerUsername, async (user, password) =>
{
var result = await _flow.SignInAsync(user, password, ct);
return result == ConnectStep.Connected ? null : ErrorText(_flow.Error);
});
if (signedIn && IsConnected)
{
Remember();
return true;
}
if (!IsConnected && _flow.Step == ConnectStep.AwaitingCredentials) _flow.Disconnect();
return false;
}
finally
{
IsBusy = false;
}
}
/// <summary>Signs out on the server and removes the token from this PC.</summary>
public async Task SignOutAsync()
{
await _flow.SignOutAsync();
ForgetToken();
}
/// <summary>Closes the connection and works locally; the saved session is kept for the next Connect.</summary>
public void Disconnect() => _flow.Disconnect();
public void StartDiscovery()
{
if (_discovery is not null) return;
_discovery = new DiscoveryListener();
_discovery.Found += server =>
{
if (Discovered.Any(d => d.Address.Equals(server.Address, StringComparison.OrdinalIgnoreCase))) return;
Discovered.Add(server);
};
_discovery.Start();
}
public void Dispose()
{
_discovery?.Dispose();
_discovery = null;
_flow.Dispose();
}
/// <summary>One sentence for a failed step (BRIEF §0.2 rule 6).</summary>
public static string ErrorText(ConnectError error) => Loc.L("Server.Error." + error);
/// <summary>The trust-on-first-use question with the fingerprint split over two lines.</summary>
public static ConfirmRequest TrustRequest(string server, string fingerprint) => new()
{
Heading = Loc.L("Server.Trust.Title"),
Message = Loc.L("Server.Trust.Message", server),
Detail = FormatFingerprint(fingerprint),
DetailToolTip = Loc.L("Tooltips.Server.Fingerprint"),
SafeText = Loc.L("Server.Trust.Cancel"),
SafeToolTip = Loc.L("Tooltips.Server.DontTrust"),
ActionText = Loc.L("Server.Trust.Accept"),
ActionToolTip = Loc.L("Tooltips.Server.Trust"),
};
/// <summary>Splits the 32-byte SHA-256 fingerprint into two lines of 16 bytes.</summary>
public static string FormatFingerprint(string fingerprint)
{
var bytes = fingerprint.Split(':');
return bytes.Length <= 16 ? fingerprint : string.Join(':', bytes.Take(16)) + "\n" + string.Join(':', bytes.Skip(16));
}
/// <summary>"9A:3C:71:E0:…" for the status line.</summary>
public static string ShortFingerprint(string fingerprint)
{
var bytes = fingerprint.Split(':');
return bytes.Length <= 4 ? fingerprint : string.Join(':', bytes.Take(4)) + ":…";
}
/// <summary>The account of the session (role, quota) for the Server screen.</summary>
public UserDto? User => IsConnected ? _flow.User : null;
private void Remember()
{
if (_flow.Address is null || _flow.Token is null) return;
var display = ServerAddress.Display(_flow.Address);
_settings.ServerUrl = display;
_settings.ServerUsername = _flow.User?.Username ?? _settings.ServerUsername;
_settings.ProtectedToken = _protector.Protect(_flow.Token);
_settings.RecentServers.RemoveAll(s => s.Equals(display, StringComparison.OrdinalIgnoreCase));
_settings.RecentServers.Insert(0, display);
if (_settings.RecentServers.Count > 8) _settings.RecentServers.RemoveRange(8, _settings.RecentServers.Count - 8);
_save();
Log.Info("server", $"Signed in to {display} as {_settings.ServerUsername}");
OnAllPropertiesChanged();
}
private void ForgetToken()
{
if (_settings.ProtectedToken is null) return;
_settings.ProtectedToken = null;
_save();
OnAllPropertiesChanged();
}
}