();
+ var multiFile = 0;
+ var videos = 0;
+ long previous = long.MaxValue;
+ string? cursor = null;
+ var pages = 0;
+ do
+ {
+ var page = await GetAsync("/api/library?limit=600" + (cursor is null ? string.Empty : "&cursor=" + Uri.EscapeDataString(cursor)));
+ foreach (var tile in page.Items("tiles"))
+ {
+ Assert.IsTrue(seen.Add(tile.Long("id")), "every entry appears once");
+ var published = tile.Long("publishedAt");
+ Assert.IsLessThanOrEqualTo(now, published, "nothing is published in the future");
+ Assert.IsLessThanOrEqualTo(previous, published, "newest first");
+ previous = published;
+ kinds.Add(tile.Str("kind"));
+ provenances.Add(tile.Str("provenance"));
+ multiFile += tile.Int("files") > 1 ? 1 : 0;
+ if (tile.GetProperty("cover").ValueKind == JsonValueKind.Object && tile.GetProperty("cover").Str("kind") == "video")
+ {
+ videos++;
+ }
+ }
+
+ cursor = page.GetProperty("older").ValueKind == JsonValueKind.String ? page.Str("older") : null;
+ pages++;
+ }
+ while (cursor is not null && pages < 100);
+
+ Assert.AreEqual(total, seen.Count, "paging reaches every entry of the day counts");
+ foreach (var kind in new[] { "post", "story", "highlight", "tagged" })
+ {
+ Assert.Contains(kind, kinds);
+ }
+
+ Assert.Contains("imported", provenances);
+ Assert.Contains("downloaded", provenances);
+ Assert.IsGreaterThan(0, multiFile, "some posts have more files");
+ Assert.IsGreaterThan(0, videos, "some entries are videos");
+ }
+
+ [TestMethod]
+ public async Task EntriesAreDiscoveredAfterPublicationAndTheirFilesLiveInTheTemporaryFolder()
+ {
+ var page = await GetAsync("/api/library?limit=400");
+ var checkedPhotos = 0;
+ var checkedVideos = 0;
+ foreach (var tile in page.Items("tiles").Where((_, i) => i % 8 == 0))
+ {
+ var entry = await GetAsync($"/api/entries/{tile.Long("id")}");
+ Assert.IsGreaterThanOrEqualTo(entry.Long("publishedAt"), entry.GetProperty("discovered").Long("ms"), "found after publication");
+ if (entry.GetProperty("downloaded").ValueKind == JsonValueKind.Object)
+ {
+ Assert.IsGreaterThanOrEqualTo(entry.GetProperty("discovered").Long("ms"), entry.GetProperty("downloaded").Long("ms"));
+ }
+
+ foreach (var media in entry.Items("media"))
+ {
+ using var file = await Client.GetAsync($"/api/media/{media.Long("id")}/file");
+ if (media.Str("kind") == "photo")
+ {
+ Assert.AreEqual(HttpStatusCode.OK, file.StatusCode);
+ Assert.AreEqual("image/jpeg", file.Content.Headers.ContentType?.MediaType);
+ var bytes = await file.Content.ReadAsByteArrayAsync();
+ Assert.IsTrue(bytes.Length > 3 && bytes[0] == 0xFF && bytes[1] == 0xD8, "a real JPEG");
+ checkedPhotos++;
+ }
+ else
+ {
+ // Videos have only their cover in the demo.
+ Assert.AreEqual(HttpStatusCode.NotFound, file.StatusCode);
+ checkedVideos++;
+ }
+ }
+ }
+
+ Assert.IsGreaterThan(0, checkedPhotos);
+ Assert.IsGreaterThan(0, checkedVideos + checkedPhotos);
+
+ var root = Path.GetFullPath(Demo.Root) + Path.DirectorySeparatorChar;
+ Assert.IsNotEmpty(Demo.World.Pictures);
+ foreach (var path in Demo.World.Pictures.Values)
+ {
+ Assert.StartsWith(root, Path.GetFullPath(path), "demo files never leave the temporary folder");
+ Assert.IsTrue(File.Exists(path), path);
+ }
+
+ var thumb = page.Items("tiles").Select(t => t.GetProperty("cover")).First(c => c.ValueKind == JsonValueKind.Object && c.GetProperty("thumb").ValueKind == JsonValueKind.String).Str("thumb");
+ using var thumbnail = await Client.GetAsync($"/api/thumbnails/{thumb}");
+ Assert.AreEqual(HttpStatusCode.OK, thumbnail.StatusCode);
+ }
+
+ [TestMethod]
+ public async Task ScenesChangeWhatTheEngineReports()
+ {
+ var normal = await GetAsync("/api/engine?scena=normale");
+ Assert.AreEqual(JsonValueKind.Null, normal.GetProperty("snapshot").GetProperty("banner").ValueKind);
+ Assert.AreEqual("connected", normal.GetProperty("connection").Str("state"));
+ CollectionAssert.Contains(new[] { "Resting", "OutsideWindow" }, normal.GetProperty("snapshot").Str("mode"));
+
+ var session = await GetAsync("/api/engine?scena=sessione");
+ Assert.AreEqual("InSession", session.GetProperty("snapshot").Str("mode"));
+
+ var stopped = await GetAsync("/api/engine?scena=fermo");
+ Assert.AreEqual("StoppedForVerification", stopped.GetProperty("snapshot").Str("mode"));
+ Assert.AreEqual(JsonValueKind.Object, stopped.GetProperty("snapshot").GetProperty("banner").ValueKind);
+ Assert.AreEqual("verification", stopped.GetProperty("connection").Str("state"));
+
+ // The scene also travels in a header (the interface sends it on every call).
+ using var request = new HttpRequestMessage(HttpMethod.Get, "/api/engine");
+ request.Headers.Add(DemoRequest.SceneHeader, "scollegato");
+ using var response = await Client.SendAsync(request);
+ using var disconnected = JsonDocument.Parse(await response.Content.ReadAsStringAsync());
+ Assert.AreEqual("NotConnected", disconnected.RootElement.GetProperty("snapshot").Str("mode"));
+ Assert.AreEqual("notConnected", disconnected.RootElement.GetProperty("connection").Str("state"));
+
+ foreach (var scene in new[] { normal, session, stopped, disconnected.RootElement })
+ {
+ foreach (var budget in scene.GetProperty("snapshot").Items("allBudgets"))
+ {
+ Assert.IsLessThanOrEqualTo(budget.Long("limitToday"), budget.Long("usedToday"), budget.Str("label"));
+ }
+ }
+
+ // Asking for a check while stopped is refused with a message.
+ var marta = (await GetAsync("/api/accounts")).Items("accounts").First(r => r.Str("username") == "marta.demo").Long("id");
+ using var check = new HttpRequestMessage(HttpMethod.Post, $"/api/accounts/{marta}/check-now?scena=fermo")
+ {
+ Content = new StringContent("{}", System.Text.Encoding.UTF8, "application/json"),
+ };
+ check.Headers.Add("Origin", $"{Demo.Address.Scheme}://{Demo.Address.Authority}");
+ using var answer = await Client.SendAsync(check);
+ using var body = JsonDocument.Parse(await answer.Content.ReadAsStringAsync());
+ Assert.AreEqual(HttpStatusCode.OK, answer.StatusCode);
+ Assert.AreEqual("refused", body.RootElement.Str("status"));
+ Assert.IsFalse(string.IsNullOrWhiteSpace(body.RootElement.Str("message")));
+ }
+
+ [TestMethod]
+ public async Task TheEditionCanBeChosenByAddress()
+ {
+ var desktop = await GetAsync("/api/capabilities");
+ Assert.IsTrue(desktop.Bool("demo"));
+ Assert.AreEqual("desktop", desktop.Str("edition"));
+ Assert.IsTrue(desktop.Bool("showInFolder"));
+ Assert.IsFalse(desktop.Bool("foldersReadOnly"));
+ Assert.AreEqual("none", desktop.Str("access"));
+
+ var docker = await GetAsync("/api/capabilities?veste=docker");
+ Assert.AreEqual("docker", docker.Str("edition"));
+ Assert.IsFalse(docker.Bool("showInFolder"));
+ Assert.IsTrue(docker.Bool("foldersReadOnly"));
+ Assert.IsFalse(docker.Bool("autostart"));
+
+ // The addresses that open a dialog or a step directly are pages of the interface.
+ foreach (var page in new[] { "/account?dialogo=aggiungi", "/importa?passo=3", "/libreria?scena=fermo&tema=scuro" })
+ {
+ using var response = await Client.GetAsync(page);
+ Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, page);
+ StringAssert.Contains(await response.Content.ReadAsStringAsync(), "The embedded interface, the page addresses and the access checks of spec §13.1.
+[TestClass]
+public sealed class HostingAndSecurityTests
+{
+ private static readonly string[] Pages =
+ [
+ "/", "/libreria", "/account", "/account/12", "/account/12/impostazioni", "/attivita", "/importa",
+ "/impostazioni/generali", "/impostazioni/limiti", "/impostazioni/collegamento", "/impostazioni/notifiche",
+ "/impostazioni/dati", "/impostazioni/informazioni", "/browser",
+ ];
+
+ [TestMethod]
+ public void TheEmbeddedInterfaceHasEveryFileAndRefusesPathsOutsideIt()
+ {
+ var files = new EmbeddedWwwroot();
+ foreach (var path in new[] { "index.html", "accesso.html", "css/febe.css", "js/app.js", "testi/it.json", "img/marchio.svg", "icone/image.svg", "caratteri/archivo-latin-standard-normal.woff2" })
+ {
+ var info = files.GetFileInfo(path);
+ Assert.IsTrue(info.Exists, path);
+ Assert.IsGreaterThan(0L, info.Length, path);
+ using var stream = info.CreateReadStream();
+ Assert.AreEqual(info.Length, stream.Length, path);
+ }
+
+ Assert.IsTrue(files.GetFileInfo("/css/febe.css").Exists, "a leading slash is accepted");
+ foreach (var bad in new[] { "../Febe.Web.dll", "css/../index.html", "./index.html", "css\\febe.css", "C:/index.html", "css//febe.css", "nonexistent.js", "" })
+ {
+ Assert.IsFalse(files.GetFileInfo(bad).Exists, bad);
+ }
+
+ var icons = files.GetDirectoryContents("icone").Select(f => f.Name).ToList();
+ Assert.Contains("image.svg", icons);
+ Assert.IsFalse(files.GetDirectoryContents("../").Exists);
+ Assert.IsTrue(files.GetDirectoryContents(string.Empty).Any(f => f.IsDirectory && f.Name == "css"));
+
+ // The text resource is valid JSON with the Italian texts.
+ using var texts = JsonDocument.Parse(files.ReadText("testi/it.json")!);
+ Assert.AreEqual("Libreria", texts.RootElement.GetProperty("nav").GetProperty("libreria").GetString());
+ }
+
+ [TestMethod]
+ public void TheIconSpriteHasOneSymbolPerLucideFileWithoutItsOwnStroke()
+ {
+ var files = new EmbeddedWwwroot();
+ var sprite = SystemApi.BuildSprite(files);
+ var count = files.Files.Count(f => f.StartsWith("icone/", StringComparison.Ordinal) && f.EndsWith(".svg", StringComparison.Ordinal));
+ Assert.AreEqual(count, sprite.Split("
", page);
+ Assert.IsTrue(response.Headers.Contains("Content-Security-Policy"), page);
+ }
+
+ using (var css = await server.Client.GetAsync("/css/febe.css"))
+ {
+ Assert.AreEqual("text/css", css.Content.Headers.ContentType?.MediaType);
+ Assert.AreEqual("nosniff", css.Headers.GetValues("X-Content-Type-Options").Single());
+ }
+
+ using (var js = await server.Client.GetAsync("/js/app.js"))
+ {
+ Assert.AreEqual("text/javascript", js.Content.Headers.ContentType?.MediaType);
+ }
+
+ using (var missing = await server.Client.GetAsync("/js/non-esiste.js"))
+ {
+ Assert.AreEqual(HttpStatusCode.NotFound, missing.StatusCode);
+ }
+
+ using var api = await server.Client.GetAsync("/api/non-esiste");
+ Assert.AreEqual(HttpStatusCode.NotFound, api.StatusCode);
+ Assert.AreEqual("application/json", api.Content.Headers.ContentType?.MediaType);
+ StringAssert.Contains(await api.Content.ReadAsStringAsync(), "sconosciuto");
+
+ var capabilities = await server.GetJsonAsync("/api/capabilities");
+ Assert.AreEqual("docker", capabilities.Str("edition"));
+ Assert.IsTrue(capabilities.Bool("foldersReadOnly"));
+ Assert.IsFalse(capabilities.Bool("showInFolder"));
+ Assert.AreEqual("2026-10-13", capabilities.Str("today"));
+ }
+
+ [TestMethod]
+ public async Task HostAndOriginChecksStopOtherPagesAndOtherNames()
+ {
+ await using var server = await WebTestServer.StartAsync();
+
+ using (var foreignHost = new HttpRequestMessage(HttpMethod.Get, "/api/capabilities"))
+ {
+ foreignHost.Headers.Host = "attacco.example:80";
+ using var response = await server.Client.SendAsync(foreignHost);
+ Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode, "DNS rebinding: a foreign host name is refused");
+ }
+
+ using (var crossOrigin = server.Request(HttpMethod.Post, "/api/engine/pause", origin: "http://attacco.example"))
+ using (var response = await server.Client.SendAsync(crossOrigin))
+ {
+ Assert.AreEqual(HttpStatusCode.Forbidden, response.StatusCode);
+ }
+
+ using (var nullOrigin = server.Request(HttpMethod.Post, "/api/engine/pause", origin: "null"))
+ using (var response = await server.Client.SendAsync(nullOrigin))
+ {
+ Assert.AreEqual(HttpStatusCode.Forbidden, response.StatusCode);
+ }
+
+ using (var crossSite = server.Request(HttpMethod.Post, "/api/engine/pause", origin: null))
+ {
+ crossSite.Headers.TryAddWithoutValidation("Sec-Fetch-Site", "cross-site");
+ using var response = await server.Client.SendAsync(crossSite);
+ Assert.AreEqual(HttpStatusCode.Forbidden, response.StatusCode);
+ }
+
+ using (var events = server.Request(HttpMethod.Get, "/api/eventi", origin: "http://attacco.example"))
+ using (var response = await server.Client.SendAsync(events))
+ {
+ Assert.AreEqual(HttpStatusCode.Forbidden, response.StatusCode, "the event stream counts as a command channel");
+ }
+
+ using (var sameOrigin = server.Request(HttpMethod.Post, "/api/engine/pause"))
+ using (var response = await server.Client.SendAsync(sameOrigin))
+ {
+ Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, await response.Content.ReadAsStringAsync());
+ }
+
+ using (var sameSite = server.Request(HttpMethod.Post, "/api/engine/pause", origin: null))
+ {
+ sameSite.Headers.TryAddWithoutValidation("Sec-Fetch-Site", "same-origin");
+ using var response = await server.Client.SendAsync(sameSite);
+ Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
+ }
+ }
+
+ [TestMethod]
+ public async Task TheDesktopTokenOpensTheInterfaceOnceAndThenLivesInAStrictCookie()
+ {
+ var token = AccessToken.Create();
+ await using var server = await WebTestServer.StartAsync(new FebeWebOptions { Edition = FebeEdition.Desktop, Access = AccessMode.Token, AccessToken = token });
+
+ using (var bare = await server.Client.GetAsync("/api/capabilities"))
+ {
+ Assert.AreEqual(HttpStatusCode.Unauthorized, bare.StatusCode);
+ }
+
+ using (var page = await server.Client.GetAsync("/libreria"))
+ {
+ Assert.AreEqual(HttpStatusCode.Unauthorized, page.StatusCode);
+ }
+
+ using (var wrong = await server.Client.GetAsync("/libreria?gettone=sbagliato"))
+ {
+ Assert.AreEqual(HttpStatusCode.Unauthorized, wrong.StatusCode);
+ }
+
+ string cookie;
+ using (var first = await server.Client.GetAsync($"/libreria?tema=scuro&gettone={token}"))
+ {
+ Assert.AreEqual(HttpStatusCode.Redirect, first.StatusCode);
+ Assert.AreEqual("/libreria?tema=scuro", first.Headers.Location?.OriginalString, "the token leaves the address at once");
+ cookie = first.Headers.GetValues("Set-Cookie").Single();
+ StringAssert.Contains(cookie, AccessToken.CookieName + "=");
+ StringAssert.Contains(cookie.ToLowerInvariant(), "httponly");
+ StringAssert.Contains(cookie.ToLowerInvariant(), "samesite=strict");
+ }
+
+ using (var withCookie = new HttpRequestMessage(HttpMethod.Get, "/api/capabilities"))
+ {
+ withCookie.Headers.TryAddWithoutValidation("Cookie", cookie.Split(';')[0]);
+ using var response = await server.Client.SendAsync(withCookie);
+ Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
+ }
+
+ using (var withHeader = new HttpRequestMessage(HttpMethod.Get, "/api/capabilities"))
+ {
+ withHeader.Headers.TryAddWithoutValidation(AccessToken.HeaderName, token);
+ using var response = await server.Client.SendAsync(withHeader);
+ Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
+ }
+
+ // The token is necessary but not sufficient: commands from another origin are refused even with it.
+ using (var forged = server.Request(HttpMethod.Post, "/api/engine/pause", origin: "http://127.0.0.1:1"))
+ {
+ forged.Headers.TryAddWithoutValidation(AccessToken.HeaderName, token);
+ using var response = await server.Client.SendAsync(forged);
+ Assert.AreEqual(HttpStatusCode.Forbidden, response.StatusCode);
+ }
+ }
+
+ [TestMethod]
+ public async Task ThePasswordOpensASessionAndRepeatedFailuresLockTheLogin()
+ {
+ await using var server = await WebTestServer.StartAsync(new FebeWebOptions
+ {
+ Access = AccessMode.Password,
+ Password = "una password lunga",
+ Lockout = new LockoutOptions { AttemptsPerClient = 3, AttemptsOverall = 50 },
+ });
+
+ using (var page = await server.Client.GetAsync("/libreria"))
+ {
+ Assert.AreEqual(HttpStatusCode.Redirect, page.StatusCode);
+ StringAssert.StartsWith(page.Headers.Location?.OriginalString, "/accesso?torna=");
+ }
+
+ using (var api = await server.Client.GetAsync("/api/accounts"))
+ {
+ Assert.AreEqual(HttpStatusCode.Unauthorized, api.StatusCode);
+ }
+
+ using (var login = await server.Client.GetAsync("/accesso"))
+ {
+ Assert.AreEqual(HttpStatusCode.OK, login.StatusCode, "the login page is public");
+ }
+
+ using (var css = await server.Client.GetAsync("/css/febe.css"))
+ {
+ Assert.AreEqual(HttpStatusCode.OK, css.StatusCode, "and so is what it needs");
+ }
+
+ var (wrong, _) = await server.SendJsonAsync(HttpMethod.Post, "/api/accesso", new { password = "no" });
+ Assert.AreEqual(HttpStatusCode.Unauthorized, wrong);
+
+ string cookie;
+ using (var ok = server.Request(HttpMethod.Post, "/api/accesso", new { password = "una password lunga" }))
+ using (var response = await server.Client.SendAsync(ok))
+ {
+ Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
+ cookie = response.Headers.GetValues("Set-Cookie").Single();
+ StringAssert.Contains(cookie.ToLowerInvariant(), "httponly");
+ StringAssert.Contains(cookie.ToLowerInvariant(), "samesite=strict");
+ }
+
+ using (var authed = new HttpRequestMessage(HttpMethod.Get, "/api/accounts"))
+ {
+ authed.Headers.TryAddWithoutValidation("Cookie", cookie.Split(';')[0]);
+ using var response = await server.Client.SendAsync(authed);
+ Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
+ }
+
+ // A login from another page is refused before the password is even checked.
+ var (foreign, _) = await SendWithOrigin(server, "/api/accesso", new { password = "una password lunga" }, "http://attacco.example");
+ Assert.AreEqual(HttpStatusCode.Forbidden, foreign);
+
+ // The right password cleared the earlier failure: the third failure from now on locks the login.
+ Assert.AreEqual(HttpStatusCode.Unauthorized, (await server.SendJsonAsync(HttpMethod.Post, "/api/accesso", new { password = "no" })).Status);
+ Assert.AreEqual(HttpStatusCode.Unauthorized, (await server.SendJsonAsync(HttpMethod.Post, "/api/accesso", new { password = "no" })).Status);
+ Assert.AreEqual(HttpStatusCode.TooManyRequests, (await server.SendJsonAsync(HttpMethod.Post, "/api/accesso", new { password = "no" })).Status);
+ Assert.AreEqual(HttpStatusCode.TooManyRequests, (await server.SendJsonAsync(HttpMethod.Post, "/api/accesso", new { password = "una password lunga" })).Status,
+ "while locked even the right password waits");
+
+ using (var logout = server.Request(HttpMethod.Post, "/api/uscita"))
+ {
+ logout.Headers.TryAddWithoutValidation("Cookie", cookie.Split(';')[0]);
+ using var response = await server.Client.SendAsync(logout);
+ Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
+ }
+
+ using (var after = new HttpRequestMessage(HttpMethod.Get, "/api/accounts"))
+ {
+ after.Headers.TryAddWithoutValidation("Cookie", cookie.Split(';')[0]);
+ using var response = await server.Client.SendAsync(after);
+ Assert.AreEqual(HttpStatusCode.Unauthorized, response.StatusCode);
+ }
+ }
+
+ [TestMethod]
+ public void TheLockoutCoversOneClientAndAllClientsAndEndsByItself()
+ {
+ var now = Make.T0;
+ var access = new PasswordAccess("segreta", new LockoutOptions { AttemptsPerClient = 2, AttemptsOverall = 3, LockFor = TimeSpan.FromMinutes(15) }, () => now);
+ Assert.AreEqual(LoginStatus.WrongPassword, access.TryLogin("x", "a").Status);
+ Assert.AreEqual(LoginStatus.Locked, access.TryLogin("x", "a").Status);
+ Assert.AreEqual(LoginStatus.Locked, access.TryLogin("segreta", "a").Status);
+ Assert.AreEqual(LoginStatus.Locked, access.TryLogin("x", "b").Status, "the third failure overall locks every client");
+ Assert.AreEqual(LoginStatus.Locked, access.TryLogin("segreta", "c").Status, "even one that never failed");
+ now += TimeSpan.FromMinutes(16);
+ var ok = access.TryLogin("segreta", "a");
+ Assert.AreEqual(LoginStatus.Accepted, ok.Status);
+ Assert.IsTrue(access.IsValid(ok.SessionId));
+ now += TimeSpan.FromDays(31);
+ Assert.IsFalse(access.IsValid(ok.SessionId), "sessions expire");
+ }
+
+ [TestMethod]
+ public async Task TheEventStreamStartsWithTheEngine()
+ {
+ await using var server = await WebTestServer.StartAsync();
+ using var request = new HttpRequestMessage(HttpMethod.Get, "/api/eventi");
+ request.Headers.TryAddWithoutValidation("Sec-Fetch-Site", "same-origin");
+ using var response = await server.Client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
+ Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
+ Assert.AreEqual("text/event-stream", response.Content.Headers.ContentType?.MediaType);
+ using var stream = await response.Content.ReadAsStreamAsync();
+ using var reader = new StreamReader(stream);
+ using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+ string? eventName = null;
+ string? data = null;
+ while (data is null)
+ {
+ var line = await reader.ReadLineAsync(timeout.Token);
+ if (line is null)
+ {
+ break;
+ }
+
+ if (line.StartsWith("event: ", StringComparison.Ordinal))
+ {
+ eventName = line[7..];
+ }
+ else if (line.StartsWith("data: ", StringComparison.Ordinal))
+ {
+ data = line[6..];
+ }
+ }
+
+ Assert.AreEqual("motore", eventName);
+ using var json = JsonDocument.Parse(data!);
+ Assert.AreEqual("Off", json.RootElement.GetProperty("snapshot").GetProperty("mode").GetString(), "without an engine Febe says «Motore spento»");
+ Assert.AreEqual("Motore spento", json.RootElement.GetProperty("snapshot").GetProperty("headline").GetString());
+ }
+
+ private static async Task<(HttpStatusCode Status, string Body)> SendWithOrigin(WebTestServer server, string path, object body, string origin)
+ {
+ using var request = server.Request(HttpMethod.Post, path, body, origin);
+ using var response = await server.Client.SendAsync(request);
+ return (response.StatusCode, await response.Content.ReadAsStringAsync());
+ }
+}
diff --git a/tests/Febe.Tests/Web/LibraryApiTests.cs b/tests/Febe.Tests/Web/LibraryApiTests.cs
new file mode 100644
index 0000000..934f6f7
--- /dev/null
+++ b/tests/Febe.Tests/Web/LibraryApiTests.cs
@@ -0,0 +1,206 @@
+using System.Net;
+using System.Text;
+using System.Text.Json;
+using Febe.Core.Domain;
+using Febe.Core.Library;
+using Febe.Tests.Support;
+using Febe.Tests.Web.Support;
+using Febe.Web.Library;
+
+namespace Febe.Tests.Web;
+
+/// The library API (spec §4.6): day groups, keyset windows, filters, viewer data, deletion, CSV export.
+[TestClass]
+public sealed class LibraryApiTests
+{
+ [TestMethod]
+ public async Task WindowsFollowTheCursorsWithoutGapsOrRepeatsAndDaysAddUp()
+ {
+ await using var server = await WebTestServer.StartAsync();
+ await server.AddAccountWithEntriesAsync("marta.demo", 40, Make.T0, TimeSpan.FromHours(5));
+ await server.AddAccountWithEntriesAsync("luca.viaggi.demo", 23, Make.T0 - TimeSpan.FromMinutes(30), TimeSpan.FromHours(7), EntryKind.Story);
+
+ var days = await server.GetJsonAsync("/api/library/days");
+ Assert.AreEqual(63, days.Int("entries"));
+ Assert.AreEqual(2, days.Int("accounts"));
+ Assert.AreEqual(63, days.Items("days").Sum(d => d.Int("count")), "the counts of the days add up to the total");
+ var dayNames = days.Items("days").Select(d => d.Str("day")).ToList();
+ CollectionAssert.AreEqual(dayNames.OrderByDescending(d => d, StringComparer.Ordinal).ToList(), dayNames, "newest day first");
+
+ var seen = new List<(long Ms, long Id)>();
+ string? cursor = null;
+ var pages = 0;
+ do
+ {
+ var page = await server.GetJsonAsync("/api/library?limit=7" + (cursor is null ? string.Empty : "&cursor=" + cursor));
+ seen.AddRange(page.Items("tiles").Select(t => (t.Long("publishedAt"), t.Long("id"))));
+ cursor = page.GetProperty("older").ValueKind == JsonValueKind.Null ? null : page.Str("older");
+ pages++;
+ }
+ while (cursor is not null && pages < 50);
+
+ Assert.HasCount(63, seen);
+ Assert.HasCount(63, seen.Select(s => s.Id).Distinct());
+ for (var i = 1; i < seen.Count; i++)
+ {
+ Assert.IsTrue(seen[i].Ms < seen[i - 1].Ms || (seen[i].Ms == seen[i - 1].Ms && seen[i].Id < seen[i - 1].Id), "display order: newest first");
+ }
+
+ // The cursor of a day starts exactly at that day.
+ foreach (var day in days.Items("days").Take(4))
+ {
+ var page = await server.GetJsonAsync($"/api/library?limit={day.Int("count")}&cursor={day.Str("cursor")}");
+ Assert.IsTrue(page.Items("tiles").All(t => t.Str("day") == day.Str("day")), day.Str("day"));
+ Assert.AreEqual(day.Int("count"), page.Items("tiles").Count());
+ }
+
+ // Going back up from a cursor gives the newer entries.
+ var middle = await server.GetJsonAsync("/api/library?limit=10&cursor=" + Uri.EscapeDataString($"{seen[30].Ms}.{seen[30].Id}"));
+ Assert.AreEqual(seen[31].Id, middle.Items("tiles").First().Long("id"));
+ var newer = await server.GetJsonAsync("/api/library?limit=5&direction=newer&cursor=" + Uri.EscapeDataString($"{seen[30].Ms}.{seen[30].Id}"));
+ CollectionAssert.AreEqual(seen.Skip(25).Take(5).Select(s => s.Id).ToList(), newer.Items("tiles").Select(t => t.Long("id")).ToList());
+ }
+
+ [TestMethod]
+ public async Task FiltersByKindAccountSearchAndPeriod()
+ {
+ await using var server = await WebTestServer.StartAsync();
+ var marta = await server.AddAccountWithEntriesAsync("marta.demo", 10, Make.T0, TimeSpan.FromDays(1), caption: "Tramonto sul molo");
+ await server.AddAccountWithEntriesAsync("luca.viaggi.demo", 6, Make.T0, TimeSpan.FromDays(1), EntryKind.Story);
+
+ Assert.AreEqual(6, (await server.GetJsonAsync("/api/library/days?kind=stories")).Int("entries"));
+ Assert.AreEqual(10, (await server.GetJsonAsync("/api/library/days?kind=photos")).Int("entries"));
+ Assert.AreEqual(0, (await server.GetJsonAsync("/api/library/days?kind=videos")).Int("entries"), "«Video» concerns posts; story videos are under «Storie»");
+ Assert.AreEqual(10, (await server.GetJsonAsync($"/api/library/days?accounts={marta.Id}")).Int("entries"));
+ Assert.AreEqual(10, (await server.GetJsonAsync("/api/library/days?q=tramonto")).Int("entries"), "caption search ignores case");
+ Assert.AreEqual(6, (await server.GetJsonAsync("/api/library/days?q=luca")).Int("entries"), "account name search");
+ Assert.AreEqual(0, (await server.GetJsonAsync("/api/library/days?provenance=imported")).Int("entries"));
+ Assert.AreEqual(6, (await server.GetJsonAsync("/api/library/days?from=2026-10-08&to=2026-10-10")).Int("entries"), "three local days, both accounts");
+
+ var (status, body) = await server.SendJsonAsync(HttpMethod.Get, "/api/library?cursor=nonvalido");
+ Assert.AreEqual(HttpStatusCode.BadRequest, status);
+ StringAssert.Contains(body.Str("message"), "non valida");
+ Assert.AreEqual(HttpStatusCode.BadRequest, (await server.SendJsonAsync(HttpMethod.Get, "/api/library/days?kind=gatti")).Status);
+ Assert.AreEqual(HttpStatusCode.BadRequest, (await server.SendJsonAsync(HttpMethod.Get, "/api/library/days?from=13/10/2026")).Status);
+ }
+
+ [TestMethod]
+ public async Task TheViewerGetsDataFilesAndProvenanceAndDeletionIsRemembered()
+ {
+ await using var server = await WebTestServer.StartAsync();
+ var account = await server.Db.Accounts.AddAsync(Make.Account("marta.demo"));
+ var folder = server.Library.Layout.AccountFolder(account);
+ Directory.CreateDirectory(Path.Combine(folder, "post"));
+ var bytes = TestImages.Jpeg(TestImages.Scene(3, 120, 150));
+ await File.WriteAllBytesAsync(Path.Combine(folder, "post", "foto_1.jpg"), bytes);
+ var added = await server.Db.Entries.AddAsync(
+ Make.Entry(account.Id, "1", Make.T0, caption: "Luce della sera") with { State = EntryState.Downloaded },
+ [Make.Stored(Make.Photo(1), Make.Sha(1), "post/foto_1.jpg") with { Bytes = bytes.Length }, Make.Stored(Make.Video(2), Make.Sha(2), "post/video_2.mp4")]);
+ var id = added.Stored.Entry.Id;
+
+ var entry = await server.GetJsonAsync($"/api/entries/{id}");
+ Assert.AreEqual("post", entry.Str("kind"));
+ Assert.AreEqual("Luce della sera", entry.Str("caption"));
+ Assert.AreEqual("C1", entry.Str("code"));
+ Assert.AreEqual("https://www.instagram.com/p/C1/", entry.Str("instagramUrl"));
+ Assert.AreEqual("2026-10-13", entry.Str("publishedDay"));
+ Assert.AreEqual("10:00", entry.Str("publishedTime"), "local time of Alberto's zone (Rome, UTC+2 in October)");
+ var media = entry.Items("media").ToList();
+ Assert.HasCount(2, media);
+ Assert.IsTrue(media[0].Bool("available"));
+ Assert.AreEqual("foto_1.jpg", media[0].Str("fileName"));
+ Assert.AreEqual(Path.Combine("marta.demo", "post"), media[0].Str("folder"));
+ Assert.IsFalse(media[1].Bool("available"), "a file missing from disk is said, not hidden");
+
+ using (var file = await server.Client.GetAsync($"/api/media/{media[0].Long("id")}/file?download=1"))
+ {
+ Assert.AreEqual(HttpStatusCode.OK, file.StatusCode);
+ Assert.AreEqual("image/jpeg", file.Content.Headers.ContentType?.MediaType);
+ Assert.AreEqual("foto_1.jpg", file.Content.Headers.ContentDisposition?.FileName?.Trim('"'));
+ CollectionAssert.AreEqual(bytes, await file.Content.ReadAsByteArrayAsync());
+ }
+
+ Assert.AreEqual(HttpStatusCode.NotFound, (await server.SendJsonAsync(HttpMethod.Get, $"/api/media/{media[1].Long("id")}/file")).Status);
+ Assert.AreEqual(HttpStatusCode.BadRequest, (await server.SendJsonAsync(HttpMethod.Get, "/api/thumbnails/nonvalida")).Status);
+ Assert.AreEqual(HttpStatusCode.NotFound, (await server.SendJsonAsync(HttpMethod.Get, "/api/thumbnails/" + Make.Sha(99))).Status);
+ using (var neutral = await server.Client.GetAsync("/api/thumbnails/video"))
+ {
+ Assert.AreEqual("image/jpeg", neutral.Content.Headers.ContentType?.MediaType);
+ }
+
+ // Without the desktop, «Mostra nella cartella» does not exist: the page offers «Scarica».
+ Assert.AreEqual(HttpStatusCode.BadRequest, (await server.SendJsonAsync(HttpMethod.Post, "/api/media/show-in-folder", new { mediaId = media[0].Long("id") })).Status);
+
+ var changes = server.Changes.SubscribeAsync().GetAsyncEnumerator();
+ var next = changes.MoveNextAsync().AsTask();
+ var (status, result) = await server.SendJsonAsync(HttpMethod.Post, "/api/entries/delete", new { ids = new[] { id }, mode = "remember" });
+ Assert.AreEqual(HttpStatusCode.OK, status);
+ Assert.AreEqual(1, result.Int("deleted"));
+ Assert.AreEqual(1, result.Int("filesRemoved"));
+ Assert.IsFalse(File.Exists(Path.Combine(folder, "post", "foto_1.jpg")));
+ Assert.AreEqual(EntryState.Deleted, (await server.Db.Entries.GetAsync(id))!.State, "remembered: never downloaded again");
+ Assert.AreEqual(0, (await server.GetJsonAsync("/api/library/days")).Int("entries"));
+ Assert.IsTrue(await next.WaitAsync(TimeSpan.FromSeconds(5)), "the open pages hear about it");
+ Assert.AreEqual("deleted", changes.Current.Reason);
+ await changes.DisposeAsync();
+
+ var after = await server.GetJsonAsync($"/api/entries/{id}");
+ Assert.AreEqual("deleted", after.Str("state"));
+ Assert.AreEqual(JsonValueKind.Null, after.GetProperty("instagramUrl").ValueKind);
+ }
+
+ [TestMethod]
+ public async Task DeletionCanLetTheEntryComeBack()
+ {
+ await using var server = await WebTestServer.StartAsync();
+ var account = await server.AddAccountWithEntriesAsync("marta.demo", 2, Make.T0, TimeSpan.FromHours(1));
+ var ids = (await server.Db.Entries.ListByAccountAsync(account.Id)).Select(e => e.Id).ToList();
+ var (status, _) = await server.SendJsonAsync(HttpMethod.Post, "/api/entries/delete", new { ids, mode = "allowReturn" });
+ Assert.AreEqual(HttpStatusCode.OK, status);
+ Assert.IsEmpty(await server.Db.Entries.ListByAccountAsync(account.Id), "forgotten: a later check may download them again");
+ Assert.AreEqual(HttpStatusCode.BadRequest, (await server.SendJsonAsync(HttpMethod.Post, "/api/entries/delete", new { ids = Array.Empty() })).Status);
+ }
+
+ [TestMethod]
+ public void CsvFieldsAreQuotedForExcelAndFormulasAreDefused()
+ {
+ Assert.AreEqual(string.Empty, CsvExport.Field(null));
+ Assert.AreEqual("semplice", CsvExport.Field("semplice"));
+ Assert.AreEqual("\"a;b\"", CsvExport.Field("a;b"));
+ Assert.AreEqual("\"dice \"\"ciao\"\"\"", CsvExport.Field("dice \"ciao\""));
+ Assert.AreEqual("\"riga\nnuova\"", CsvExport.Field("riga\nnuova"));
+ Assert.AreEqual("\" spazio\"", CsvExport.Field(" spazio"));
+ Assert.AreEqual("\"'=1+1\"", CsvExport.Field("=1+1"));
+ Assert.AreEqual("\"'@marta ciao\"", CsvExport.Field("@marta ciao"));
+ Assert.AreEqual("\"'-3\"", CsvExport.Field("-3"));
+ Assert.AreEqual("a;\"b;c\";", CsvExport.Line(["a", "b;c", null]));
+ }
+
+ [TestMethod]
+ public async Task TheExportIsUtf8WithBomSemicolonsAndOneLinePerEntry()
+ {
+ await using var server = await WebTestServer.StartAsync();
+ var account = await server.AddAccountWithEntriesAsync("marta.demo", 3, Make.T0, TimeSpan.FromDays(1), caption: "Città; mare e \"sole\"\nseconda riga");
+ var ids = (await server.Db.Entries.ListByAccountAsync(account.Id)).Select(e => e.Id).ToList();
+
+ using var request = server.Request(HttpMethod.Post, "/api/entries/export", new { ids });
+ using var response = await server.Client.SendAsync(request);
+ Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
+ Assert.AreEqual("text/csv", response.Content.Headers.ContentType?.MediaType);
+ Assert.AreEqual("attachment", response.Content.Headers.ContentDisposition?.DispositionType);
+ StringAssert.EndsWith(response.Content.Headers.ContentDisposition?.FileName?.Trim('"'), ".csv");
+ var bytes = await response.Content.ReadAsByteArrayAsync();
+ CollectionAssert.AreEqual(new byte[] { 0xEF, 0xBB, 0xBF }, bytes.Take(3).ToArray(), "UTF-8 with BOM for Excel");
+ var text = Encoding.UTF8.GetString(bytes, 3, bytes.Length - 3);
+ StringAssert.StartsWith(text, string.Join(';', CsvExport.Header) + "\r\n");
+ StringAssert.Contains(text, "\"Città; mare e \"\"sole\"\"\nseconda riga\"");
+ StringAssert.Contains(text, "marta.demo;Post;13/10/2026;10:00:00;");
+ Assert.AreEqual(4, text.Split("\r\n", StringSplitOptions.RemoveEmptyEntries).Length, "header and three entries");
+
+ // By filter: the same query the page uses.
+ using var byFilter = server.Request(HttpMethod.Post, "/api/entries/export", new { query = "kind=photos&from=2026-10-12" });
+ using var filtered = await server.Client.SendAsync(byFilter);
+ var filteredText = Encoding.UTF8.GetString(await filtered.Content.ReadAsByteArrayAsync());
+ Assert.AreEqual(3, filteredText.Split("\r\n", StringSplitOptions.RemoveEmptyEntries).Length, "header and the two entries of 12 and 13 October");
+ }
+}
diff --git a/tests/Febe.Tests/Web/Support/WebTestServer.cs b/tests/Febe.Tests/Web/Support/WebTestServer.cs
new file mode 100644
index 0000000..2587b4d
--- /dev/null
+++ b/tests/Febe.Tests/Web/Support/WebTestServer.cs
@@ -0,0 +1,157 @@
+using System.Net;
+using System.Net.Http.Json;
+using System.Text;
+using System.Text.Json;
+using Febe.Core.Abstractions;
+using Febe.Core.Domain;
+using Febe.Core.Library;
+using Febe.Core.Storage;
+using Febe.Data;
+using Febe.Tests.Support;
+using Febe.Web;
+using Febe.Web.Library;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Febe.Tests.Web.Support;
+
+///
+/// Febe.Web on a real Kestrel listening on 127.0.0.1 with a free port (no test server package needed), with a
+/// temporary database and library, and an HttpClient pointed at it.
+///
+internal sealed class WebTestServer : IAsyncDisposable
+{
+ private WebTestServer(TempFolder temp, FebeDatabase db, FebeLibrary library, ManualClock clock, WebApplication app, Uri address)
+ {
+ Temp = temp;
+ Db = db;
+ Library = library;
+ Clock = clock;
+ App = app;
+ Address = address;
+ Client = NewClient();
+ }
+
+ public TempFolder Temp { get; }
+
+ public FebeDatabase Db { get; }
+
+ public FebeLibrary Library { get; }
+
+ public ManualClock Clock { get; }
+
+ public WebApplication App { get; }
+
+ public Uri Address { get; }
+
+ /// A client without cookies of its own (each test decides what to send).
+ public HttpClient Client { get; }
+
+ /// «http://127.0.0.1:port», the value of Origin for requests coming from the interface.
+ public string Origin => $"{Address.Scheme}://{Address.Authority}";
+
+ public LibraryChanges Changes => App.Services.GetRequiredService();
+
+ public static async Task StartAsync(FebeWebOptions? options = null, Action? services = null)
+ {
+ var temp = new TempFolder("web");
+ var db = await FebeDatabase.OpenAsync(temp.Combine("dati"));
+ var clock = new ManualClock(Make.T0);
+ var library = new FebeLibrary(db, new DataFolderLayout(temp.Combine("dati")), new LibraryLayout(temp.Combine("libreria")), clock);
+ options ??= new FebeWebOptions { Access = AccessMode.None };
+ options = options with { AllowedHosts = options.AllowedHosts.Count == 0 ? FebeWebOptions.LoopbackHosts(0) : options.AllowedHosts };
+ var app = FebeWebHost.Build(options, FebeListen.Loopback(0), s =>
+ {
+ s.AddSingleton(db);
+ s.AddSingleton(library);
+ s.AddSingleton(clock);
+ services?.Invoke(s);
+ });
+ await app.StartAsync();
+ return new WebTestServer(temp, db, library, clock, app, FebeWebHost.BoundAddress(app));
+ }
+
+ public HttpClient NewClient(bool cookies = false, bool redirects = false)
+ {
+ var handler = new HttpClientHandler { AllowAutoRedirect = redirects, UseCookies = cookies, CookieContainer = new CookieContainer() };
+ return new HttpClient(handler) { BaseAddress = Address, Timeout = TimeSpan.FromSeconds(30) };
+ }
+
+ /// A request as the interface sends it (Origin of the interface on commands).
+ public HttpRequestMessage Request(HttpMethod method, string path, object? body = null, string? origin = "")
+ {
+ var request = new HttpRequestMessage(method, path);
+ if (body is not null)
+ {
+ request.Content = new StringContent(body as string ?? JsonSerializer.Serialize(body, Json), Encoding.UTF8, "application/json");
+ }
+
+ if (origin is not null)
+ {
+ request.Headers.TryAddWithoutValidation("Origin", origin.Length == 0 ? Origin : origin);
+ }
+
+ return request;
+ }
+
+ public static readonly JsonSerializerOptions Json = new(JsonSerializerDefaults.Web);
+
+ public async Task GetJsonAsync(string path)
+ {
+ using var response = await Client.GetAsync(path);
+ var text = await response.Content.ReadAsStringAsync();
+ Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, $"{path}: {text}");
+ return JsonDocument.Parse(text).RootElement.Clone();
+ }
+
+ public async Task<(HttpStatusCode Status, JsonElement Body)> SendJsonAsync(HttpMethod method, string path, object? body = null)
+ {
+ using var request = Request(method, path, body);
+ using var response = await Client.SendAsync(request);
+ var text = await response.Content.ReadAsStringAsync();
+ var json = text.Length > 0 && (response.Content.Headers.ContentType?.MediaType?.Contains("json", StringComparison.Ordinal) ?? false)
+ ? JsonDocument.Parse(text).RootElement.Clone()
+ : default;
+ return (response.StatusCode, json);
+ }
+
+ /// Adds an account with a few stored entries spread over days (no files on disk).
+ public async Task AddAccountWithEntriesAsync(string username, int entries, DateTimeOffset newest, TimeSpan step, EntryKind kind = EntryKind.Post, string? caption = null)
+ {
+ var account = await Db.Accounts.AddAsync(Make.Account(username));
+ var items = new List();
+ for (var i = 0; i < entries; i++)
+ {
+ var media = Make.Stored(kind == EntryKind.Story ? Make.Video() : Make.Photo(), Make.Sha((1000 * username.Length) + i + 1), $"post/{username}-{i}.jpg");
+ items.Add(new NewEntry(Make.Entry(account.Id, $"{username}-{i}", newest - (step * i), kind, caption) with { State = EntryState.Downloaded }, [media]));
+ }
+
+ await Db.Entries.AddManyAsync(items);
+ return account;
+ }
+
+ public async ValueTask DisposeAsync()
+ {
+ Client.Dispose();
+ await App.StopAsync();
+ await App.DisposeAsync();
+ await Db.DisposeAsync();
+ Temp.Dispose();
+ }
+}
+
+/// Small JSON helpers for the API answers.
+internal static class JsonAnswers
+{
+ public static string Str(this JsonElement e, string name) => e.GetProperty(name).GetString() ?? string.Empty;
+
+ public static int Int(this JsonElement e, string name) => e.GetProperty(name).GetInt32();
+
+ public static long Long(this JsonElement e, string name) => e.GetProperty(name).GetInt64();
+
+ public static bool Bool(this JsonElement e, string name) => e.GetProperty(name).GetBoolean();
+
+ public static JsonElement.ArrayEnumerator Items(this JsonElement e, string name) => e.GetProperty(name).EnumerateArray();
+
+ public static Task ReadAsync(this HttpContent content) => content.ReadFromJsonAsync(WebTestServer.Json);
+}
diff --git a/tools/schermate/passi/aggiungi.js b/tools/schermate/passi/aggiungi.js
new file mode 100644
index 0000000..c50d7ce
--- /dev/null
+++ b/tools/schermate/passi/aggiungi.js
@@ -0,0 +1,6 @@
+// Chooses three followed profiles in the «Aggiungi account» dialog (mockup 04).
+await new Promise((r) => setTimeout(r, 800));
+const boxes = [...document.querySelectorAll('.aggiungi .elenco input[type=checkbox]:not(:disabled)')];
+for (const i of [0, 2, 5]) if (boxes[i]) boxes[i].click();
+await new Promise((r) => setTimeout(r, 400));
+return document.querySelector('.aggiungi footer .btn.primo')?.textContent;
diff --git a/tools/schermate/passi/puntatore.js b/tools/schermate/passi/puntatore.js
new file mode 100644
index 0000000..fa764b5
--- /dev/null
+++ b/tools/schermate/passi/puntatore.js
@@ -0,0 +1,7 @@
+// Moves the pointer over the widest tile near the top of the mosaic (hover state of mockup 01).
+const tiles = [...document.querySelectorAll('.tess[data-id]')];
+const wide = tiles
+ .filter((t) => t.getBoundingClientRect().top < 500)
+ .sort((a, b) => b.getBoundingClientRect().width - a.getBoundingClientRect().width)[0];
+const r = wide.getBoundingClientRect();
+return { hover: [Math.round(r.left + r.width / 2), Math.round(r.top + r.height / 2)], label: wide.getAttribute('aria-label') };
diff --git a/tools/schermate/passi/visualizzatore.js b/tools/schermate/passi/visualizzatore.js
new file mode 100644
index 0000000..0130543
--- /dev/null
+++ b/tools/schermate/passi/visualizzatore.js
@@ -0,0 +1,9 @@
+// Opens a post with more files in the viewer and shows its second file (mockup 02).
+const tiles = [...document.querySelectorAll('.tess[data-id]')];
+const multi = tiles.find((t) => t.querySelector('use[href="#i-layers"]') && !t.querySelector('use[href="#i-circle-dashed"]') && !t.querySelector('use[href="#i-play"]')) || tiles[0];
+multi.click();
+await new Promise((r) => setTimeout(r, 1500));
+const second = document.querySelectorAll('.vis .serie button')[1];
+if (second) second.click();
+await new Promise((r) => setTimeout(r, 1200));
+return document.querySelector('.vis .dove')?.textContent;
diff --git a/tools/schermate/schermata.mjs b/tools/schermate/schermata.mjs
new file mode 100644
index 0000000..039e964
--- /dev/null
+++ b/tools/schermate/schermata.mjs
@@ -0,0 +1,119 @@
+// node tools/schermate/schermata.mjs [larghezza] [altezza] [attesa-ms] [passo.js]
+//
+// Screenshot of Febe's own interface (spec §10.7) through the DevTools protocol of a Chromium without window:
+// exact viewport at scale 1.25 (like the mockups), console errors printed, an optional step (a JS file evaluated in
+// the page and awaited; when it returns { hover: [x, y] } the pointer is moved there, so :hover styles show).
+//
+// Only for Febe's own interface: the address must be on this computer (127.0.0.1 or localhost). Instagram is never
+// opened this way (spec §2, rule 4). Needs Node 22 or later (global WebSocket) and a Chromium: set FEBE_CHROMIUM, or
+// the Playwright build under /opt/pw-browsers is used.
+import { spawn } from 'node:child_process';
+import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const [address, out, width = '1440', height = '900', wait = '3000', step] = process.argv.slice(2);
+if (!address || !out) {
+ console.error('Uso: node tools/schermate/schermata.mjs [larghezza] [altezza] [attesa-ms] [passo.js]');
+ process.exit(2);
+}
+
+const target = new URL(address);
+if (!['127.0.0.1', 'localhost', '[::1]'].includes(target.hostname)) {
+ console.error('Solo l\'interfaccia di Febe su questo computer (127.0.0.1 o localhost).');
+ process.exit(2);
+}
+
+function findChromium() {
+ if (process.env.FEBE_CHROMIUM) return process.env.FEBE_CHROMIUM;
+ const root = '/opt/pw-browsers';
+ if (existsSync(root)) {
+ for (const name of readdirSync(root).filter((n) => /^chromium-\d+$/.test(n)).sort().reverse()) {
+ const candidate = join(root, name, 'chrome-linux', 'chrome');
+ if (existsSync(candidate)) return candidate;
+ }
+ }
+ console.error('Chromium non trovato: indica il percorso in FEBE_CHROMIUM.');
+ process.exit(2);
+}
+
+const profile = mkdtempSync(join(tmpdir(), 'febe-schermata-'));
+const port = 9300 + Math.floor(Math.random() * 500);
+const chrome = spawn(findChromium(), [
+ '--headless', '--no-sandbox', '--disable-gpu', '--hide-scrollbars', '--disable-background-networking',
+ '--disable-component-update', '--no-first-run', '--no-default-browser-check', '--disable-extensions',
+ `--user-data-dir=${profile}`, `--remote-debugging-port=${port}`, '--remote-debugging-address=127.0.0.1', 'about:blank',
+], { stdio: 'ignore' });
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+function finish(code) {
+ chrome.kill('SIGKILL');
+ setTimeout(() => {
+ try {
+ rmSync(profile, { recursive: true, force: true });
+ } catch {
+ // the profile stays in the temporary folder
+ }
+ process.exit(code);
+ }, 300);
+}
+
+let ws;
+for (let i = 0; i < 50 && !ws; i++) {
+ try {
+ const list = await (await fetch(`http://127.0.0.1:${port}/json/list`)).json();
+ const page = list.find((t) => t.type === 'page');
+ if (page) ws = new WebSocket(page.webSocketDebuggerUrl);
+ } catch {
+ // Chromium is still starting
+ }
+ if (!ws) await sleep(200);
+}
+if (!ws) {
+ console.error('Chromium non risponde.');
+ finish(1);
+} else {
+ await new Promise((r) => ws.addEventListener('open', r));
+ let id = 0;
+ const pending = new Map();
+ ws.addEventListener('message', (e) => {
+ const msg = JSON.parse(e.data);
+ if (msg.id && pending.has(msg.id)) {
+ pending.get(msg.id)(msg);
+ pending.delete(msg.id);
+ } else if (msg.method === 'Runtime.consoleAPICalled' && ['error', 'warning'].includes(msg.params.type)) {
+ console.log(`console.${msg.params.type}:`, msg.params.args.map((a) => a.value ?? a.description).join(' '));
+ } else if (msg.method === 'Runtime.exceptionThrown') {
+ console.log('eccezione:', msg.params.exceptionDetails.exception?.description || msg.params.exceptionDetails.text);
+ } else if (msg.method === 'Log.entryAdded' && msg.params.entry.level === 'error') {
+ console.log('errore:', msg.params.entry.text, msg.params.entry.url || '');
+ }
+ });
+ const send = (method, params = {}) => new Promise((resolve) => {
+ const n = ++id;
+ pending.set(n, resolve);
+ ws.send(JSON.stringify({ id: n, method, params }));
+ });
+ await send('Runtime.enable');
+ await send('Log.enable');
+ await send('Page.enable');
+ await send('Emulation.setDeviceMetricsOverride', { width: Number(width), height: Number(height), deviceScaleFactor: 1.25, mobile: false });
+ await send('Page.navigate', { url: target.href });
+ await sleep(Number(wait));
+ if (step) {
+ const code = readFileSync(step, 'utf8');
+ const r = await send('Runtime.evaluate', { expression: `(async () => { ${code} })()`, awaitPromise: true, returnByValue: true });
+ const value = r.result?.result?.value;
+ if (r.result?.exceptionDetails) console.log('errore nel passo:', r.result.exceptionDetails.exception?.description);
+ else if (value !== undefined) console.log('passo:', JSON.stringify(value));
+ if (value && typeof value === 'object' && Array.isArray(value.hover)) {
+ await send('Input.dispatchMouseEvent', { type: 'mouseMoved', x: value.hover[0], y: value.hover[1] });
+ }
+ await sleep(800);
+ }
+ const shot = await send('Page.captureScreenshot', { format: 'png' });
+ writeFileSync(out, Buffer.from(shot.result.data, 'base64'));
+ console.log('salvata', out);
+ ws.close();
+ finish(0);
+}
diff --git a/tools/schermate/tutte.sh b/tools/schermate/tutte.sh
new file mode 100644
index 0000000..a7f2283
--- /dev/null
+++ b/tools/schermate/tutte.sh
@@ -0,0 +1,23 @@
+#!/bin/bash
+# Retakes the screenshots of docs/schermate from a running demo (spec §10.7):
+# dotnet run --project src/Febe.Server -- --demo --porta 8490 (in another terminal)
+# bash tools/schermate/tutte.sh [porta] [cartella]
+# One screenshot at a time: Chromium and the demo share the computer.
+set -u
+here="$(cd "$(dirname "$0")" && pwd)"
+port="${1:-8480}"
+out="${2:-$here/../../docs/schermate}"
+b="http://127.0.0.1:$port"
+mkdir -p "$out"
+shot() { echo "== $2"; timeout 90 node "$here/schermata.mjs" "$1" "$out/$2" "${3:-1440}" "${4:-900}" "${5:-3000}" ${6:-}; }
+shot "$b/libreria?tema=chiaro" 01-libreria.png 1440 900 3000 "$here/passi/puntatore.js"
+shot "$b/libreria?tema=chiaro" 02-visualizzatore.png 1440 900 3000 "$here/passi/visualizzatore.js"
+shot "$b/account?tema=chiaro" 03-account.png
+shot "$b/account?tema=chiaro" 03-account-telefono.png 390 844
+shot "$b/account?dialogo=aggiungi&tema=chiaro" 04-aggiungi-account.png 1440 900 3000 "$here/passi/aggiungi.js"
+shot "$b/account/3/impostazioni?tema=chiaro" 05-account-impostazioni.png
+shot "$b/libreria?scena=fermo&tema=scuro" 11-libreria-fermo-tema-scuro.png
+shot "$b/account/2?tema=scuro&tipo=storie" 12-account-storie-tema-scuro.png
+shot "$b/libreria?tema=chiaro" 14-finestra-stretta.png 860 900
+shot "$b/libreria?tema=chiaro" 14-telefono.png 390 844
+shot "$b/account/2/cronologia?tema=chiaro" account-cronologia.png