diff --git a/app/lib/features/attention/notify/notification_bridge.dart b/app/lib/features/attention/notify/notification_bridge.dart new file mode 100644 index 00000000..b1ec61bd --- /dev/null +++ b/app/lib/features/attention/notify/notification_bridge.dart @@ -0,0 +1,30 @@ +import 'notification_bridge_stub.dart' + if (dart.library.js_interop) 'notification_bridge_web.dart' + as impl; +import 'notification_models.dart'; + +/// Where the notification capability actually posts. +/// +/// The controller depends on this, not on any platform, so the dedupe, the +/// permission rules and the content are all testable without a browser. A bridge +/// answers the platform's real facts and never guesses: [environment] returns +/// what the platform says (including "unsupported"), [requestPermission] is only +/// called from an explicit gesture, and [show] reports whether the platform +/// accepted the notification. +abstract interface class NotificationBridge { + /// The platform's own facts: support, secure context and permission word. + NotificationEnvironment environment(); + + /// Asks the platform, from an explicit operator gesture, and returns its own + /// answer word. Never a guess, and never called by the controller on its own. + Future requestPermission(); + + /// Shows one notification, attaching [onTap] as its tap intent when given. + /// Returns whether the platform accepted it. + bool show(NotificationMessage message, {void Function()? onTap}); +} + +/// The bridge for the current platform: the browser `Notification` on the web, +/// an honest "unsupported" elsewhere. +NotificationBridge createNotificationBridge() => + impl.createNotificationBridge(); diff --git a/app/lib/features/attention/notify/notification_bridge_stub.dart b/app/lib/features/attention/notify/notification_bridge_stub.dart new file mode 100644 index 00000000..94e837ea --- /dev/null +++ b/app/lib/features/attention/notify/notification_bridge_stub.dart @@ -0,0 +1,27 @@ +import 'notification_bridge.dart'; +import 'notification_models.dart'; + +/// The non-web bridge: there is no browser Notification API to reach. +/// +/// It reports `unsupported` honestly rather than pretending a notification was +/// shown, so the surface falls back to the in-app `Needs you` channel. A native +/// platform notifier would replace this through the same seam. +class UnsupportedNotificationBridge implements NotificationBridge { + const UnsupportedNotificationBridge(); + + @override + NotificationEnvironment environment() => const NotificationEnvironment( + supported: false, + secureContext: false, + permission: 'default', + ); + + @override + Future requestPermission() async => 'default'; + + @override + bool show(NotificationMessage message, {void Function()? onTap}) => false; +} + +NotificationBridge createNotificationBridge() => + const UnsupportedNotificationBridge(); diff --git a/app/lib/features/attention/notify/notification_bridge_web.dart b/app/lib/features/attention/notify/notification_bridge_web.dart new file mode 100644 index 00000000..dcd1374f --- /dev/null +++ b/app/lib/features/attention/notify/notification_bridge_web.dart @@ -0,0 +1,95 @@ +import 'dart:js_interop'; +import 'dart:js_interop_unsafe'; + +import 'notification_bridge.dart'; +import 'notification_models.dart'; + +/// The browser's `Notification` constructor. +/// +/// Declared with `dart:js_interop` rather than `dart:html`, so the same source +/// compiles for the JavaScript and WebAssembly web targets. Every member is +/// reached only after [_supported] has confirmed the global exists, so an +/// unsupported browser never touches it. +@JS('Notification') +extension type _Notification._(JSObject _) implements JSObject { + external factory _Notification(JSString title, _NotificationOptions options); + + external static JSString get permission; + + external static JSPromise requestPermission(); + + external set onclick(JSFunction? handler); +} + +/// The `{ body, tag }` options object one notification is created with. +extension type _NotificationOptions._(JSObject _) implements JSObject { + external factory _NotificationOptions({JSString body, JSString tag}); +} + +/// Whether `globalThis.Notification` is really a constructor right now. +bool _supported() => + globalContext.getProperty('Notification'.toJS).isA(); + +/// The browser's own secure-context flag; anything but a real boolean is false. +bool _secureContext() { + final value = globalContext.getProperty('isSecureContext'.toJS); + return value.isA() && (value as JSBoolean).toDart; +} + +/// The browser bridge: the real `Notification` API, reached through +/// `dart:js_interop`. +/// +/// Nothing is fabricated. [environment] reports the constructor's own +/// `permission` word and the page's own `isSecureContext`; an unsupported +/// browser is reported as unsupported rather than as a default grant. +class WebNotificationBridge implements NotificationBridge { + const WebNotificationBridge(); + + @override + NotificationEnvironment environment() { + if (!_supported()) { + return const NotificationEnvironment( + supported: false, + secureContext: false, + permission: 'default', + ); + } + final raw = _Notification.permission.toDart; + return NotificationEnvironment( + supported: true, + secureContext: _secureContext(), + permission: raw == 'granted' || raw == 'denied' ? raw : 'default', + ); + } + + @override + Future requestPermission() async { + if (!_supported()) return 'default'; + try { + return (await _Notification.requestPermission().toDart).toDart; + } catch (_) { + // A browser that refuses the request keeps the honest fallback wording. + return 'default'; + } + } + + @override + bool show(NotificationMessage message, {void Function()? onTap}) { + if (!_supported()) return false; + try { + final notification = _Notification( + message.title.toJS, + _NotificationOptions(body: message.body.toJS, tag: message.tag.toJS), + ); + final open = onTap; + if (open != null) notification.onclick = (() => open()).toJS; + return true; + } catch (_) { + // Some browsers can throw even with permission granted; the in-app Needs + // you surface remains the only honest channel and nothing is faked. + return false; + } + } +} + +NotificationBridge createNotificationBridge() => const WebNotificationBridge(); diff --git a/app/lib/features/attention/notify/notification_controller.dart b/app/lib/features/attention/notify/notification_controller.dart new file mode 100644 index 00000000..84f195d9 --- /dev/null +++ b/app/lib/features/attention/notify/notification_controller.dart @@ -0,0 +1,250 @@ +import 'dart:async'; + +import 'package:flutter/foundation.dart'; + +import '../domain/attention_transitions.dart'; +import 'notification_bridge.dart'; +import 'notification_ledger.dart'; +import 'notification_models.dart'; +import 'notification_store.dart'; + +/// The live notification capability behind the `Needs you` surface. +/// +/// It never invents a permission: [permission] is the platform's own answer, +/// read from the [NotificationBridge], and `granted` is only ever reported when +/// the platform said so. Nothing asks for permission on its own — +/// [requestPermission] is the one explicit call — and a denied answer is never +/// re-asked. +/// +/// Only live attention transitions raise a notification: the caller publishes +/// the transitions the attention model raised (never the initial seed), and one +/// identity is posted at most once per entry into its run's qualifying state, +/// including across a reconnect, because the ledger records the identity before +/// the platform is asked to show it. A dismissed identity is recorded but never +/// shown. +/// +/// The manager wires it: set [onOpenRun] to open a run, call [load] once, and +/// after *every* authoritative read and pushed frame call [publishTransitions] +/// with the attention controller's accumulated transitions, its current rows +/// (through [notificationQualifyingKeys]) and its dismissed set. Publishing the +/// frame that leaves a state is what forgets the old identity, so the next gate +/// or retry is a new announcement. The call is idempotent, so passing the whole +/// accumulated list is safe. +class NotificationController extends ChangeNotifier { + NotificationController({required this.store, NotificationBridge? bridge}) + : bridge = bridge ?? createNotificationBridge(); + + /// The most notifications one publish posts, so a burst cannot flood the tray. + static const maxNotificationsPerBatch = 5; + + final NotificationStore store; + final NotificationBridge bridge; + + /// The tap seam: the manager sets this to open a run. Nothing here navigates. + void Function(int runId)? onOpenRun; + + NotificationLedger _ledger = const NotificationLedger(); + NotificationPermissionState _permission = + NotificationPermissionState.unsupported; + bool _loaded = false; + bool _disposed = false; + int _posted = 0; + + /// The transition instance announced this session for each identity: a new + /// instance means the run entered the state again. + final Map _announced = {}; + + /// The queued ledger writes, so an older snapshot cannot land after a newer one. + Future _writes = Future.value(); + + /// The platform's own permission state for this page. + NotificationPermissionState get permission => _permission; + + /// True once the persisted ledger and the platform facts have been read. + bool get loaded => _loaded; + + /// Whether the operator has ever been asked for permission. + bool get asked => _ledger.asked; + + /// A copy of the transition identities this client has already announced. + /// Returned unmodifiable, so a caller cannot mutate the ledger behind + /// [publishTransitions]' back. + Set get notified => Set.unmodifiable(_ledger.notified); + + /// True only when the platform itself reported `granted`. + bool get canNotify => _permission == NotificationPermissionState.granted; + + /// How many notifications this session has actually posted. + int get postedCount => _posted; + + /// Reads the persisted ledger and the platform's real permission facts once. + Future load() async { + NotificationLedger ledger; + try { + ledger = decodeNotificationLedger(await store.read()); + } catch (_) { + ledger = const NotificationLedger(); + } + if (_disposed) return; + _ledger = ledger; + _announced.clear(); + _permission = notificationStateOf(bridge.environment()); + _loaded = true; + notifyListeners(); + } + + /// Re-reads the platform's facts without asking anything, for example after + /// the browser's site settings changed and the page regained focus. + void refreshPermission() { + if (_disposed) return; + final next = notificationStateOf(bridge.environment()); + if (next == _permission) return; + _permission = next; + notifyListeners(); + } + + /// The one explicit request, only ever called from an operator gesture. + /// + /// A supported, secure page that has not decided is asked, and every other + /// state answers with the platform's own word instead of prompting again. The + /// request is issued before any await, so it stays inside the gesture that + /// triggered it. + Future requestPermission() async { + if (_disposed) return _permission; + final environment = bridge.environment(); + _permission = notificationStateOf(environment); + if (_permission != NotificationPermissionState.notRequested) { + notifyListeners(); + return _permission; + } + // The operator was asked, whatever the answer; persisted without awaiting so + // the platform request stays in this gesture's frame. + _ledger = _ledger.withAsked(true); + unawaited(_persist(_ledger)); + notifyListeners(); + + String answer; + try { + answer = await bridge.requestPermission(); + } catch (_) { + answer = ''; + } + if (_disposed) return _permission; + final word = answer.trim().toLowerCase(); + _permission = notificationStateOf( + NotificationEnvironment( + supported: environment.supported, + secureContext: environment.secureContext, + permission: word == 'granted' || word == 'denied' + ? word + : environment.permission, + ), + ); + notifyListeners(); + return _permission; + } + + /// Posts one notification per live transition, in order. + /// + /// [qualifying] is [notificationQualifyingKeys] for the *same* snapshot as + /// [transitions]: a transition whose run has left the state is stale and + /// neither posts nor records anything, then every recorded identity outside + /// [qualifying] is forgotten so the next gate can notify. Only the latest + /// entry per run+kind in a backlog is announced. + /// + /// A caller that misses the leaving frame still gets the new transition: the + /// detector creates one instance per genuine transition, so an identity + /// announced earlier this session with a different instance is a new + /// occurrence; the same instance, and an identity loaded from the store before + /// this session, stay silent. + /// + /// The initial seed raises no transition. A transition the operator dismissed, + /// one already recorded and one past [maxNotificationsPerBatch] post nothing. + /// Returns how many notifications the platform accepted. + int publishTransitions( + Iterable transitions, { + required Set qualifying, + Set dismissed = const {}, + }) { + if (_disposed) return 0; + var posted = 0; + var changed = false; + // A backlog may hold several entries for one run+kind; only the latest one + // describes the state that is current, so a coalesced burst notifies once. + final latest = {}; + for (final transition in transitions) { + latest[notificationIdentity(transition)] = transition; + } + for (final transition in latest.values) { + if (posted >= maxNotificationsPerBatch) break; + final identity = notificationIdentity(transition); + // Older than the snapshot: the run already left this state. + if (!qualifying.contains(identity)) continue; + final announced = _announced[identity]; + if (identical(announced, transition)) continue; + if (announced == null && _ledger.hasNotified(identity)) { + // Restored from the store before this session: adopt the instance so a + // republish is recognized, but do not announce it again. + _announced[identity] = transition; + continue; + } + // A new instance for an identity announced this session is a later entry. + if (!_ledger.hasNotified(identity)) { + _ledger = _ledger.recording(identity); + changed = true; + } + _announced[identity] = transition; + if (dismissed.contains(identity)) continue; + if (!canNotify) continue; + final open = onOpenRun; + final message = NotificationMessage( + runId: transition.runId, + title: notificationAlertTitle(transition.kind), + body: notificationAlertBody(transition.entry), + tag: identity, + ); + var shown = false; + try { + shown = bridge.show( + message, + onTap: open == null ? null : () => open(transition.runId), + ); + } catch (_) { + shown = false; + } + if (shown) { + posted++; + _posted++; + } + } + final pruned = _ledger.pruning(qualifying); + if (!identical(pruned, _ledger)) { + _ledger = pruned; + changed = true; + } + if (changed) unawaited(_persist(_ledger)); + return posted; + } + + /// Writes the ledger without ever throwing into the caller's frame, one write + /// at a time so their order matches the calls. + Future _persist(NotificationLedger ledger) { + final encoded = encodeNotificationLedger(ledger); + final write = _writes.then((_) async { + if (_disposed) return; + try { + await store.write(encoded); + } catch (_) { + // The in-memory ledger still applies for this session. + } + }); + _writes = write; + return write; + } + + @override + void dispose() { + _disposed = true; + super.dispose(); + } +} diff --git a/app/lib/features/attention/notify/notification_ledger.dart b/app/lib/features/attention/notify/notification_ledger.dart new file mode 100644 index 00000000..2a88f3d2 --- /dev/null +++ b/app/lib/features/attention/notify/notification_ledger.dart @@ -0,0 +1,122 @@ +import 'dart:convert'; + +import '../../../core/api_gateway.dart'; +import '../domain/attention_models.dart'; +import '../domain/attention_transitions.dart'; + +/// This client's own storage key for the notification ledger, namespaced like +/// the rest of the app. It is deliberately not the legacy web key, so neither +/// client rewrites the other's local state on a shared origin. +const notificationStorageKey = 'pipelines.next.notify.v1'; + +/// The identity of one announced transition: the run and kind, exactly the +/// attention surface's own key and the browser's `alertKey`. +/// +/// It is deliberately *not* keyed by a timestamp. A waiting run has no +/// `finished_at`, and its creation time never changes, so a marker derived from +/// them cannot tell a run's first decision gate from a later one. Instead the +/// ledger only holds identities for the runs that are qualifying *right now*: +/// [notificationQualifyingKeys] supplies that set, and an identity is forgotten +/// as soon as its run leaves the qualifying state (see [NotificationLedger.pruning]). +/// The next entry into the same state is therefore a new announcement, exactly +/// as in `web/src/notify.js`. +String notificationIdentity(AttentionTransition transition) => transition.key; + +/// The `{runId}:{Kind}` identities of the runs currently in a qualifying state, +/// built from the same rows the attention surface draws. +/// +/// Dismissals and the local-day window are deliberately ignored: a dismissal +/// does not stop a run qualifying, and an old failure is still the same +/// announced transition rather than a new one. +Set notificationQualifyingKeys(Iterable? runs) { + final keys = {}; + for (final run in runs ?? const []) { + final runId = attentionRunId(run['run_id']) ?? attentionRunId(run['id']); + final kind = attentionKindForRun(run); + if (runId == null || kind == null) continue; + keys.add(attentionKey(runId, kind)); + } + return keys; +} + +/// What this client has already announced, plus whether the operator has ever +/// been asked. +/// +/// The ledger is pure: it records identities, decides whether one is new and +/// drops the ones whose run no longer qualifies. Persistence is the store's job. +/// +/// An identity lives only while its run is in the qualifying state it announced: +/// publishing the same list again is idempotent, a reconnect cannot repeat a +/// notification, and a genuinely new transition (a second decision gate, or a +/// later failure of a new run id) notifies once more because leaving the state +/// dropped the old identity. This is the browser's `forget` model; unlike a +/// timestamp marker it can tell two decision gates of one run apart. +class NotificationLedger { + const NotificationLedger({ + this.notified = const {}, + this.asked = false, + }); + + /// The transition identities already recorded, in no particular order. + final Set notified; + + /// Whether the operator has ever been asked for permission. + final bool asked; + + bool hasNotified(String identity) => notified.contains(identity); + + /// The ledger with [identity] recorded. + NotificationLedger recording(String identity) => + NotificationLedger(notified: {...notified, identity}, asked: asked); + + NotificationLedger withAsked(bool value) => + NotificationLedger(notified: notified, asked: value); + + /// The ledger with every identity outside [qualifying] dropped. + /// + /// A run that is no longer failed or waiting has left its announced state, so + /// a later entry is a new event and must be able to notify again. Keeping only + /// the current qualifying identities also bounds the ledger to the runs the + /// surface currently holds instead of growing with every event ever seen. + NotificationLedger pruning(Set qualifying) { + final kept = notified.where(qualifying.contains).toSet(); + if (kept.length == notified.length) return this; + return NotificationLedger(notified: kept, asked: asked); + } +} + +/// The one-line JSON the ledger is stored as. The identities are sorted so an +/// unchanged ledger always encodes to the same bytes. +String encodeNotificationLedger(NotificationLedger ledger) { + final identities = ledger.notified.where((id) => id.isNotEmpty).toList() + ..sort(); + return jsonEncode({'asked': ledger.asked, 'notified': identities}); +} + +/// Decodes a stored value into a ledger. Total: blank text, unreadable JSON, a +/// non-map, a non-boolean `asked` and non-string members all decode to the +/// members that can be read, and a malformed value never throws. +/// +/// A value written by an older build may still contain timestamped identities; +/// they simply stop matching [notificationQualifyingKeys] and are dropped on the +/// next publish, so no migration step is needed. +NotificationLedger decodeNotificationLedger(String? stored) { + final text = (stored ?? '').trim(); + if (text.isEmpty) return const NotificationLedger(); + dynamic parsed; + try { + parsed = jsonDecode(text); + } catch (_) { + return const NotificationLedger(); + } + if (parsed is! Map) return const NotificationLedger(); + final raw = parsed['notified']; + return NotificationLedger( + notified: { + if (raw is List) + for (final value in raw) + if (value is String && value.isNotEmpty) value, + }, + asked: parsed['asked'] == true, + ); +} diff --git a/app/lib/features/attention/notify/notification_models.dart b/app/lib/features/attention/notify/notification_models.dart new file mode 100644 index 00000000..f817c92e --- /dev/null +++ b/app/lib/features/attention/notify/notification_models.dart @@ -0,0 +1,169 @@ +import '../domain/attention_models.dart'; + +/// The permission state the notification surface reports. +/// +/// The Dart names are this client's; [wireName] is the browser model's own word +/// (`unsupported` | `insecure` | `default` | `granted` | `denied`) so the two +/// clients' vocabularies stay traceable. [notRequested] is the Notification +/// API's `default`: supported and secure, but the operator has not decided yet. +enum NotificationPermissionState { + unsupported('unsupported'), + needsSecureContext('insecure'), + notRequested('default'), + granted('granted'), + denied('denied'); + + const NotificationPermissionState(this.wireName); + + /// The browser model's own word for this state (`web/src/notify.js`). + final String wireName; +} + +/// The platform's own notification facts, as the bridge answers them. +/// +/// [permission] is the Notification API's raw word; anything unrecognised is +/// read as `default` rather than guessed, exactly as the browser does. +class NotificationEnvironment { + const NotificationEnvironment({ + required this.supported, + required this.secureContext, + required this.permission, + }); + + final bool supported; + final bool secureContext; + final String permission; +} + +/// The permission state for one environment. +/// +/// Only the platform's own answers decide it: an unsupported API and an +/// insecure page are reported before the permission word, and `granted` is never +/// assumed — a page that has not been granted stays [notRequested]. +NotificationPermissionState notificationStateOf( + NotificationEnvironment environment, +) { + if (!environment.supported) return NotificationPermissionState.unsupported; + if (!environment.secureContext) { + return NotificationPermissionState.needsSecureContext; + } + switch (environment.permission) { + case 'granted': + return NotificationPermissionState.granted; + case 'denied': + return NotificationPermissionState.denied; + default: + return NotificationPermissionState.notRequested; + } +} + +/// Android's NOTIFICATION_RATIONALE, verbatim (`RunAlerts.kt`, `notify.js`). +const notificationRationale = + 'Pipelines can notify you when a run is waiting for your decision or has ' + 'failed. Without it, those runs still appear in the in-app Needs you ' + 'surface.'; + +/// The Settings section heading and the explicit-gesture action label. +const notificationSectionTitle = 'Notifications'; +const notificationRequestLabel = 'Enable notifications'; + +/// The honest wording for every state, verbatim from `web/src/notify.js`; each +/// says plainly that the in-app `Needs you` surface is the only channel when the +/// platform cannot notify. +const notificationUnsupportedCopy = + 'This browser does not support notifications. The in-app Needs you surface ' + 'is the only channel.'; +const notificationInsecureCopy = + 'Notifications need a secure context (https or localhost). This page is not ' + 'secure, so the in-app Needs you surface is the only channel.'; +const notificationGrantedCopy = + 'Notifications are on. Failed and waiting runs will raise a browser ' + 'notification.'; +const notificationDeniedCopy = + 'Notifications are blocked for this site. Allow them in the browser\'s site ' + 'settings to use them; until then the in-app Needs you surface is the only ' + 'channel.'; +const notificationDefaultCopy = + 'Notifications are off. Enable them to be told when a run fails or needs ' + 'your decision.'; +const notificationDefaultAskedCopy = + 'Notifications are still off. Your browser did not grant permission when ' + 'asked; you can ask again, or the in-app Needs you surface remains the only ' + 'channel.'; + +/// The total permission view for the Settings tile. +/// +/// Only a supported, secure page whose permission is still `default` offers the +/// request control, and [asked] only changes the honest wording — nothing here +/// asks for permission on its own. +class NotificationPermissionView { + const NotificationPermissionView({ + required this.state, + required this.body, + required this.canRequest, + required this.actionLabel, + required this.asked, + }); + + final NotificationPermissionState state; + final String body; + final bool canRequest; + final String? actionLabel; + final bool asked; +} + +/// The view for one state, with the browser's own copy for it. +NotificationPermissionView notificationPermissionView( + NotificationPermissionState state, { + bool asked = false, +}) { + final canRequest = state == NotificationPermissionState.notRequested; + final body = switch (state) { + NotificationPermissionState.unsupported => notificationUnsupportedCopy, + NotificationPermissionState.needsSecureContext => notificationInsecureCopy, + NotificationPermissionState.granted => notificationGrantedCopy, + NotificationPermissionState.denied => notificationDeniedCopy, + NotificationPermissionState.notRequested => + asked ? notificationDefaultAskedCopy : notificationDefaultCopy, + }; + return NotificationPermissionView( + state: state, + body: body, + canRequest: canRequest, + actionLabel: canRequest ? notificationRequestLabel : null, + asked: asked, + ); +} + +/// The short headline one kind shows; the browser's `alertTitle` verbatim. +String notificationAlertTitle(AttentionKind kind) => switch (kind) { + AttentionKind.decision => 'A run needs your decision', + AttentionKind.failed => 'A run failed', +}; + +/// The line naming the run: its label, then the pipeline it belongs to. +/// +/// The words are the entry's own — a blank or equal pipeline is never repeated, +/// so there is no trailing separator and nothing is invented. +String notificationAlertBody(AttentionEntry entry) { + final pipeline = entry.pipeline; + final label = entry.label; + if (pipeline.isEmpty || pipeline == label) return label; + return '$label \u00b7 $pipeline'; +} + +/// One notification the platform is asked to show: the entry's own words, plus +/// the stable identity used as the browser's coalescing tag. +class NotificationMessage { + const NotificationMessage({ + required this.runId, + required this.title, + required this.body, + required this.tag, + }); + + final int runId; + final String title; + final String body; + final String tag; +} diff --git a/app/lib/features/attention/notify/notification_store.dart b/app/lib/features/attention/notify/notification_store.dart new file mode 100644 index 00000000..27b53806 --- /dev/null +++ b/app/lib/features/attention/notify/notification_store.dart @@ -0,0 +1,83 @@ +import 'package:shared_preferences/shared_preferences.dart'; + +import 'notification_ledger.dart'; + +/// The persistence seam for the notification ledger. +/// +/// The controller only ever hands over the exact string produced by +/// [encodeNotificationLedger], so a store cannot invent a different format. +/// Both directions are allowed to fail: a caller treats a null read as "nothing +/// recorded yet" and a false write as "this session only". +abstract interface class NotificationStore { + Future read(); + + Future write(String value); +} + +/// `shared_preferences` storage under the ledger's own key. +/// +/// Reads and writes are total: an unavailable plugin, a disabled store or a full +/// disk returns null/false instead of throwing into the caller's frame. Only the +/// documented [notificationStorageKey] is touched, never the attention key or the +/// legacy web key. +class SharedPreferencesNotificationStore implements NotificationStore { + const SharedPreferencesNotificationStore(); + + Future _preferences() async { + try { + return await SharedPreferences.getInstance(); + } catch (_) { + return null; + } + } + + @override + Future read() async { + final preferences = await _preferences(); + if (preferences == null) return null; + try { + return preferences.getString(notificationStorageKey); + } catch (_) { + return null; + } + } + + @override + Future write(String value) async { + final preferences = await _preferences(); + if (preferences == null) return false; + try { + return await preferences.setString(notificationStorageKey, value); + } catch (_) { + return false; + } + } +} + +/// An in-memory store for tests and isolated fixtures. +/// +/// It never touches the platform store, so a probe or widget test cannot mutate +/// a real operator's persisted ledger. [failReads] and [failWrites] reproduce an +/// unavailable store without throwing. +class MemoryNotificationStore implements NotificationStore { + MemoryNotificationStore({this.stored}); + + String? stored; + bool failReads = false; + bool failWrites = false; + int writes = 0; + + @override + Future read() async { + if (failReads) throw StateError('notification store unavailable'); + return stored; + } + + @override + Future write(String value) async { + writes++; + if (failWrites) throw StateError('notification store is read-only'); + stored = value; + return true; + } +} diff --git a/app/lib/features/attention/ui/notification_permission_tile.dart b/app/lib/features/attention/ui/notification_permission_tile.dart new file mode 100644 index 00000000..16de654d --- /dev/null +++ b/app/lib/features/attention/ui/notification_permission_tile.dart @@ -0,0 +1,127 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; + +import '../../../ui/adaptive/host.dart'; +import '../notify/notification_models.dart'; + +/// The permission tile's root, so a caller can find it whichever host draws it. +const notificationTileKey = ValueKey('notification-permission-tile'); + +/// The explicit-gesture Enable action, present only when a request is possible. +const notificationEnableKey = ValueKey( + 'notification-permission-enable', +); + +/// The honest state line, which says plainly when the in-app surface is the +/// only channel. +const notificationStateKey = ValueKey('notification-permission-state'); + +/// The reusable Notifications permission tile for Settings. +/// +/// It renders the platform's own [state] with the browser's own copy, shows the +/// Android rationale verbatim, and offers the [notificationRequestLabel] action +/// only while a request is still possible. Nothing here asks for permission on +/// its own — [onRequest] is the caller's explicit-gesture handler, and the tile +/// never guesses a grant. +/// +/// The caller owns the surrounding section/card and passes the live state; the +/// tile reads no store, bridge or clock. +class NotificationPermissionTile extends StatelessWidget { + const NotificationPermissionTile({ + super.key, + required this.state, + this.asked = false, + this.onRequest, + this.cupertino, + }); + + final NotificationPermissionState state; + + /// Whether the operator has already been asked; only changes the wording. + final bool asked; + + /// The explicit-gesture handler. Absent means no action is drawn even when a + /// request would be possible. + final VoidCallback? onRequest; + + /// Forces the native host in tests and fixtures; otherwise the ambient + /// [usesCupertinoHost] decides. + final bool? cupertino; + + @override + Widget build(BuildContext context) { + final view = notificationPermissionView(state, asked: asked); + final native = cupertino ?? usesCupertinoHost(context); + final action = view.canRequest && onRequest != null + ? _action(native, view.actionLabel!, onRequest!) + : null; + final bodyStyle = native + ? CupertinoTheme.of(context).textTheme.textStyle.copyWith( + color: CupertinoColors.secondaryLabel.resolveFrom(context), + ) + : Theme.of(context).textTheme.bodyMedium?.copyWith( + color: Theme.of(context).colorScheme.onSurfaceVariant, + ); + return Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + native + ? CupertinoListTile( + key: notificationTileKey, + leading: const Icon(CupertinoIcons.bell), + title: const Text(notificationSectionTitle), + ) + : ListTile( + key: notificationTileKey, + leading: const Icon(Icons.notifications_outlined), + title: const Text(notificationSectionTitle), + ), + Padding( + padding: const EdgeInsetsDirectional.fromSTEB(16, 0, 16, 12), + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text(notificationRationale, style: bodyStyle), + const SizedBox(height: 8), + Semantics( + liveRegion: true, + child: Text( + view.body, + key: notificationStateKey, + style: bodyStyle, + ), + ), + // The action sits on its own row, as the browser's settings + // section does: a native button in a row's trailing slot would + // squeeze the section title to one character per line at large + // text, and its label is too long to share the row. + if (action != null) ...[ + const SizedBox(height: 8), + Align( + alignment: AlignmentDirectional.centerStart, + child: action, + ), + ], + ], + ), + ), + ], + ); + } + + Widget _action(bool native, String label, VoidCallback onRequest) { + if (native) { + return CupertinoButton( + key: notificationEnableKey, + padding: EdgeInsets.zero, + onPressed: onRequest, + child: Text(label), + ); + } + return TextButton( + key: notificationEnableKey, + onPressed: onRequest, + child: Text(label), + ); + } +} diff --git a/app/notes/A2-notify.md b/app/notes/A2-notify.md new file mode 100644 index 00000000..ad484ee6 --- /dev/null +++ b/app/notes/A2-notify.md @@ -0,0 +1,182 @@ +# A2 — notification capability behind a platform seam + +The notification capability exists as reusable Dart under +`lib/features/attention/notify/`, plus one reusable Settings tile at +`lib/features/attention/ui/notification_permission_tile.dart`. Nothing was wired +into the shell, `Settings`, the application or the Runs screen; outside those +paths only this note, the notify tests and the isolated probe changed. + +## What is there + +| File | Lines | Role | +| --- | --- | --- | +| `notify/notification_models.dart` | 169 | permission state, environment, copy, permission view, alert title/body, `NotificationMessage` | +| `notify/notification_bridge.dart` | 30 | the abstract `NotificationBridge` + the conditional-import factory | +| `notify/notification_bridge_web.dart` | 95 | the real `Notification` API via `dart:js_interop` (no `package:web`) | +| `notify/notification_bridge_stub.dart` | 27 | non-web stub that reports `unsupported` honestly | +| `notify/notification_ledger.dart` | 122 | run+kind identity, the qualifying-key set, ledger with pruning, total JSON codec, `pipelines.next.notify.v1` | +| `notify/notification_store.dart` | 83 | injectable store seam; total `shared_preferences` impl + memory impl | +| `notify/notification_controller.dart` | 250 | the `ChangeNotifier` capability | +| `ui/notification_permission_tile.dart` | 127 | the reusable native tile | +| `tool/notification_probe.dart` / `.mjs` | 291 / 314 | isolated real-browser probe | + +## Platform seam + +`NotificationBridge` answers the platform's own facts +(`environment()` → `supported`, `secureContext`, raw `permission`), +`requestPermission()` (only ever called from an explicit gesture) and +`show(message, onTap:)`. The web bridge declares `@JS('Notification')` with +`external factory`, `external static permission`, `external static +requestPermission` and an `onclick` setter, and reaches the global only after a +`globalContext` support check, so an unsupported browser is never touched. The +stub returns `supported: false` and `show() == false`. + +`NotificationController.permission` is one of `unsupported`, +`needsSecureContext`, `notRequested` (the API's own `default` — `default` is a +Dart reserved word, and each state exposes `wireName` = `unsupported` | +`insecure` | `default` | `granted` | `denied`), `granted`, `denied`. It is +derived only from `notificationStateOf(environment)`; `granted` is never assumed +from an unrecognised word. `requestPermission()` asks only while the state is +still `notRequested`, issues the platform request before any `await` so it stays +inside the gesture, persists `asked` without awaiting, and follows the platform's +answer. A denied state is never re-prompted. + +## Notify only on live transitions, dedupe per qualifying state + +The identity is the attention surface's own `{runId}:{Kind}` key, which is also +the browser's `alertKey` and therefore the coalescing `tag`: + +- The initial list seed raises no transition, so `publishTransitions` over the + attention controller's (empty) transition list posts nothing. +- `publishTransitions(transitions, qualifying:, dismissed:)` receives + `notificationQualifyingKeys(attention.rows)` — the `{runId}:{Kind}` keys of the + runs that are failed or waiting *right now*. A transition whose key is not in + that set is stale (the caller's accumulated list still holds it because the run + has moved on), so it neither posts nor re-records anything. +- At the end of the publish, every recorded identity outside the qualifying set + is forgotten ([`NotificationLedger.pruning`]). Publishing the frame that + *leaves* the state is what makes the next gate (or a later failure of a new + run id) a new announcement. + This is the browser's `forget`/`pruneNotified` model. +- A waiting run has no `finished_at`, so a timestamp marker cannot separate its + first decision gate from a later one. The run+kind identity plus pruning can: + `waiting -> running -> waiting` notifies once per gate even though both + entries carry identical timestamps. A retry that produces a new failed run id + is likewise a new identity; a failed run id never returns to running. +- A caller that misses the frame that leaves the state is still handled: the + attention detector creates one transition instance per genuine transition, so + an identity announced earlier in this session with a different instance is a + new occurrence and notifies. Republishing the same instance stays silent. +- The same transition can never notify twice across a republish, a reconnect + reseed, or a controller rebuilt over the same store while the run still + qualifies. The ledger records the identity before the platform is asked to + show it and persists it under `pipelines.next.notify.v1` through the injectable + `NotificationStore`. A value written by the previous timestamp-identity build + stops matching the qualifying set and is dropped on the next publish, so no + migration step is needed. +- The ledger is bounded by the runs currently qualifying, not by the history of + every event the install has ever seen. +- Writes are serialized through one queued future, so an older snapshot can + never land after a newer one, and a throwing read/write is swallowed: the + in-memory ledger still applies for the session. +- A dismissed identity is recorded but never shown (the transition detector + already suppresses it; the publish guard covers a caller that passes it). +- Content is the entry's own words: the kind headline (`A run failed` / `A run + needs your decision`) and `label · pipeline`, matching `web/src/notify.js` and + `RunAlerts.kt` verbatim. Nothing is invented, and no `stage` field is added + because neither reference client's alert body carries one. +- A batch posts in order, bounded to `maxNotificationsPerBatch` (5); the rest are + posted on the next call because the ones already posted are recorded. +- `notified` returns an unmodifiable copy, so a caller cannot mutate the ledger + behind the controller's back. + +## Wiring the manager still owes + +```dart +final notify = NotificationController(store: const SharedPreferencesNotificationStore()); +notify.onOpenRun = (runId) { /* open that run — navigation lives here, not in notify */ }; +await notify.load(); +// after *every* authoritative read and pushed frame the attention controller handles: +notify.publishTransitions( + attention.transitions, + qualifying: notificationQualifyingKeys(attention.rows), + dismissed: attention.dismissed, +); +``` + +Publishing on the frames that leave a state matters as much as publishing the +one that entered it: that is when the old identity is forgotten. `load()` once, +and `publishTransitions` on every frame/seed, is enough; it is idempotent. +`refreshPermission()` re-reads the platform facts after a focus change. The tile +is embedded by the Settings screen with the live `state`/`asked` and an +`onRequest` that calls `notify.requestPermission()`. + +## Tests and evidence + +- `flutter test test/features/attention` — **147 passed** (12 more than before + this change; the notify/tile files hold 55). New coverage in this change: the + `waiting -> running -> waiting` second gate with the real waiting shape (empty + `finished_at`) notifies again, with and without publishing the leaving frame; + a coalesced backlog of two gates notifies once; a stale transition from a run + that left is not re-posted; the identity is run+kind so two alerts of one run + share the browser tag; pruning drops identities outside the qualifying set; + old timestamped identities are dropped; `notificationQualifyingKeys` ignores + export waits, malformed ids and duplicates; `notified` is unmodifiable; ledger + writes are serialized in call order. +- `flutter test` (whole app) — **1058 passed**. +- `flutter analyze` — **No issues found** (whole project). +- `dart format --output=none --set-exit-if-changed` on every new lib/test file — + clean. +- `flutter build web` (the real `lib/main.dart`) — **succeeded**. This does *not* + compile the notify feature: nothing under `lib/` imports it yet, so the main + bundle contains none of its strings. It is a sanity check for the app only. +- `flutter build web -t tool/notification_probe.dart -o build/notification_probe_web` + — **succeeded**. This is the build that compiles the conditional-import web + bridge (`isSecureContext`, the alert copy and the real `Notification` seam are + in this bundle). +- Real-browser probe (`tool/notification_probe.dart` + `.mjs`, isolated loopback + server, `Browser.grantPermissions` / `Browser.setPermission`, + `window.Notification` replaced with a recording spy before load): + **all 29 checks passed** — seed posted 0; one transition posted exactly 1 with + title `A run failed`, body `Nightly audit · nightly` and tag `1:Failed`; a + dismissed transition posted 0; a reconnect replay posted 1 in total; a second + decision gate posted exactly 2 in total, both tag `7:Decision`, with the + waiting frames carrying no `finished_at`; denied and unsupported pages posted 0 + and read their honest copy; all five tile states read correctly on Material + **and** Cupertino at 320 logical px / 2x. +- 13 PNG captures regenerated in + `/Users/alan/.local/share/pipelines/data/artifacts/100/public/captures/notify/` + (`notification-transition-…`, `notification-denied-…`, + `notification-unsupported-…`, and + `notification-tile-{unsupported,insecure,default,granted,denied}-{material,cupertino}-dark-320-2x.png`). + +One UI defect was found by the first captures and fixed in the previous visit: +putting the Enable action in a `ListTile` trailing slot squeezed the section title +to one glyph per line at 320 px / 2x, so the action now sits on its own row below +the copy (as the browser's settings section does), and the widget test guards it. + +## Deliberate limits + +- `PARITY.md`'s `Notifications` row is **still Missing**: this slice is a + capability plus a reusable tile, not a delivered Settings section or shell + wiring. The row should move when the manager embeds the tile and wires the + controller, with authenticated smoke evidence. +- The instance rule is session-local. A controller rebuilt over the same store + can only distinguish a later gate if the frame that left the state was + published (which prunes the old identity), so the wiring above still publishes + every authoritative read and frame rather than only entering transitions. +- A browser whose `Notification.requestPermission()` uses the legacy + callback-only form (no returned promise) falls back to the honest default + wording, as the web client also does. +- Mobile (Android/iOS) is unverified: the stub reports `unsupported` and no + device or OS notification behaviour was exercised. No `pubspec` change. +- The tile is not registered in Settings and background chat-question notices + (`web/src/app.js` `notifyChatQuestion`) are not part of this capability. + +## Manager completion after the Code deadline + +The run succeeded at Code, was rejected once at Review, and the retry hit the +30-minute deadline. The retained tree is complete: 147 attention tests pass and +analysis is clean. Merged directly. Shell wiring (permission tile in Settings and +transition delivery from the Runs attention controller) is the manager's next +step and is not claimed here. diff --git a/app/test/features/attention/notify/notification_controller_test.dart b/app/test/features/attention/notify/notification_controller_test.dart new file mode 100644 index 00000000..d792689f --- /dev/null +++ b/app/test/features/attention/notify/notification_controller_test.dart @@ -0,0 +1,181 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/attention/notify/notification_controller.dart'; +import 'package:pipelines_app/features/attention/notify/notification_store.dart'; + +import 'notification_test_support.dart'; + +void main() { + group('the seed never notifies', () { + test('an already failed and waiting list is silent', () async { + final attention = attentionController(); + final bridge = FakeNotificationBridge(); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(attention.dispose); + addTearDown(notify.dispose); + await attention.load(); + await notify.load(); + + attention.seedRows([ + runSummary(1, 'failed', diagnostic: 'Stage 3 stopped'), + runSummary(2, 'waiting'), + ]); + + expect(attention.transitions, isEmpty); + expect(publish(notify, attention), 0); + expect(bridge.shown, isEmpty); + }); + }); + + group('a live transition notifies once', () { + test('the frame\'s own words and identity are used', () async { + final attention = attentionController(); + final bridge = FakeNotificationBridge(permission: 'granted'); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(attention.dispose); + addTearDown(notify.dispose); + await attention.load(); + await notify.load(); + expect(notify.canNotify, isTrue); + + attention.seedRows([runSummary(1, 'running', name: 'nightly')]); + attention.observeFrame( + runFrame( + 1, + 'failed', + name: 'nightly', + title: 'Nightly audit', + diagnostic: 'Stage 3 stopped', + finishedAt: '2026-10-22T11:00:00Z', + ), + ); + + expect(publish(notify, attention), 1); + final message = bridge.shown.single; + expect(message.title, 'A run failed'); + expect(message.body, 'Nightly audit \u00b7 nightly'); + expect(message.tag, '1:Failed'); + expect(message.runId, 1); + }); + + test('a duplicate frame and a republished list stay silent', () async { + final attention = attentionController(); + final bridge = FakeNotificationBridge(permission: 'granted'); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(attention.dispose); + addTearDown(notify.dispose); + await attention.load(); + await notify.load(); + + attention.seedRows([runSummary(1, 'running')]); + attention.observeFrame(runFrame(1, 'failed')); + expect(publish(notify, attention), 1); + + attention.observeFrame(runFrame(1, 'failed')); + expect(attention.transitions, hasLength(1)); + expect(publish(notify, attention), 0); + expect(bridge.shown, hasLength(1)); + }); + + test('a reconnect reseed cannot replay the notification', () async { + final attention = attentionController(); + final bridge = FakeNotificationBridge(permission: 'granted'); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(attention.dispose); + addTearDown(notify.dispose); + await attention.load(); + await notify.load(); + + attention.seedRows([runSummary(1, 'running')]); + attention.observeFrame(runFrame(1, 'failed')); + expect(publish(notify, attention), 1); + + attention.resetForReconnect(); + attention.seedRows([runSummary(1, 'failed')], reconnect: true); + expect(publish(notify, attention), 0); + attention.observeFrame(runFrame(1, 'failed')); + expect(publish(notify, attention), 0); + expect(bridge.shown, hasLength(1)); + }); + + test('a rebuilt controller with the same store stays silent', () async { + final store = MemoryNotificationStore(); + final bridge = FakeNotificationBridge(permission: 'granted'); + final attention = attentionController(); + final notify = NotificationController(store: store, bridge: bridge); + addTearDown(attention.dispose); + addTearDown(notify.dispose); + await attention.load(); + await notify.load(); + + attention.seedRows([runSummary(1, 'running')]); + attention.observeFrame(runFrame(1, 'failed')); + expect(publish(notify, attention), 1); + await settle(); + + final restarted = NotificationController(store: store, bridge: bridge); + addTearDown(restarted.dispose); + await restarted.load(); + expect(restarted.notified, contains('1:Failed')); + expect(publish(restarted, attention), 0); + expect(bridge.shown, hasLength(1)); + }); + + test('a later failure of another run notifies independently', () async { + final attention = attentionController(); + final bridge = FakeNotificationBridge(permission: 'granted'); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(attention.dispose); + addTearDown(notify.dispose); + await attention.load(); + await notify.load(); + + attention.seedRows([runSummary(1, 'running'), runSummary(2, 'running')]); + attention.observeFrame(runFrame(1, 'failed')); + expect(publish(notify, attention), 1); + + attention.observeFrame(runFrame(2, 'failed')); + expect(publish(notify, attention), 1); + expect(bridge.shown, hasLength(2)); + expect(bridge.shown.map((m) => m.tag), ['1:Failed', '2:Failed']); + }); + + test('a transition for a run that left is never re-posted', () async { + final attention = attentionController(); + final bridge = FakeNotificationBridge(permission: 'granted'); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(attention.dispose); + addTearDown(notify.dispose); + await attention.load(); + await notify.load(); + + attention.seedRows([runSummary(1, 'running')]); + attention.observeFrame(runFrame(1, 'failed')); + expect(publish(notify, attention), 1); + + // Publishing the leaving frame forgets the identity; republishing the + // accumulated list afterwards must not resurrect the old alert. + attention.observeFrame(runFrame(1, 'running')); + expect(publish(notify, attention), 0); + expect(publish(notify, attention), 0); + expect(bridge.shown, hasLength(1)); + }); + }); +} diff --git a/app/test/features/attention/notify/notification_delivery_test.dart b/app/test/features/attention/notify/notification_delivery_test.dart new file mode 100644 index 00000000..5573cc8d --- /dev/null +++ b/app/test/features/attention/notify/notification_delivery_test.dart @@ -0,0 +1,238 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/attention/domain/attention_models.dart'; +import 'package:pipelines_app/features/attention/notify/notification_bridge.dart'; +import 'package:pipelines_app/features/attention/notify/notification_controller.dart'; +import 'package:pipelines_app/features/attention/notify/notification_models.dart'; +import 'package:pipelines_app/features/attention/notify/notification_store.dart'; + +import 'notification_test_support.dart'; + +void main() { + group('a dismissed entry never notifies', () { + test('the detector suppresses it and nothing is posted', () async { + final attention = attentionController(); + final bridge = FakeNotificationBridge(permission: 'granted'); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(attention.dispose); + addTearDown(notify.dispose); + await attention.load(); + await notify.load(); + + attention.seedRows([runSummary(1, 'running')]); + await attention.dismiss(attentionEntryFor(runSummary(1, 'failed'))!); + attention.observeFrame(runFrame(1, 'failed')); + + expect(attention.transitions, isEmpty); + expect(publish(notify, attention), 0); + expect(bridge.shown, isEmpty); + }); + + test( + 'the publish guard records but does not show a dismissed key', + () async { + final bridge = FakeNotificationBridge(permission: 'granted'); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(notify.dispose); + await notify.load(); + + final transition = transitionFor(4); + expect( + notify.publishTransitions( + [transition], + qualifying: {transition.key}, + dismissed: {transition.key}, + ), + 0, + ); + expect(notify.notified, contains(transition.key)); + expect(bridge.shown, isEmpty); + }, + ); + }); + + group('batching and the tap seam', () { + test('a burst posts a bounded batch in order, then the rest', () async { + final bridge = FakeNotificationBridge(permission: 'granted'); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(notify.dispose); + await notify.load(); + + final transitions = [for (var id = 1; id <= 7; id++) transitionFor(id)]; + final qualifying = {for (final t in transitions) t.key}; + expect(notify.publishTransitions(transitions, qualifying: qualifying), 5); + expect(bridge.shown.map((m) => m.runId), [1, 2, 3, 4, 5]); + expect(notify.publishTransitions(transitions, qualifying: qualifying), 2); + expect(bridge.shown.map((m) => m.runId), [1, 2, 3, 4, 5, 6, 7]); + }); + + test('a tap reports the run and never navigates here', () async { + final bridge = FakeNotificationBridge(permission: 'granted'); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(notify.dispose); + await notify.load(); + + final opened = []; + notify.onOpenRun = opened.add; + expect( + notify.publishTransitions([transitionFor(3)], qualifying: {'3:Failed'}), + 1, + ); + bridge.taps.single!.call(); + expect(opened, [3]); + }); + }); + + group('the ledger cannot be read into by a caller', () { + test('notified is an unmodifiable copy', () async { + final bridge = FakeNotificationBridge(permission: 'granted'); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(notify.dispose); + await notify.load(); + + expect( + notify.publishTransitions([transitionFor(1)], qualifying: {'1:Failed'}), + 1, + ); + expect(notify.notified, {'1:Failed'}); + expect(() => notify.notified.add('9:Failed'), throwsUnsupportedError); + expect(notify.notified, {'1:Failed'}); + }); + }); + + group('an unavailable store cannot reach the UI', () { + test('a failed read and write still notify and never throw', () async { + final store = MemoryNotificationStore() + ..failReads = true + ..failWrites = true; + final bridge = FakeNotificationBridge(permission: 'granted'); + final notify = NotificationController(store: store, bridge: bridge); + addTearDown(notify.dispose); + + await expectLater(notify.load(), completes); + expect(notify.loaded, isTrue); + expect(notify.notified, isEmpty); + + expect( + notify.publishTransitions([transitionFor(1)], qualifying: {'1:Failed'}), + 1, + ); + await settle(); + expect(bridge.shown, hasLength(1)); + }); + + test('a throwing platform post is reported, not propagated', () async { + final bridge = _ThrowingBridge(); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(notify.dispose); + await notify.load(); + + expect( + notify.publishTransitions([transitionFor(1)], qualifying: {'1:Failed'}), + 0, + ); + expect(notify.notified, contains('1:Failed')); + }); + + test('ledger writes land in call order, one at a time', () async { + final store = _SlowStore(); + final bridge = FakeNotificationBridge(permission: 'granted'); + final notify = NotificationController(store: store, bridge: bridge); + addTearDown(notify.dispose); + await notify.load(); + + notify.publishTransitions([transitionFor(1)], qualifying: {'1:Failed'}); + notify.publishTransitions( + [transitionFor(2)], + qualifying: {'1:Failed', '2:Failed'}, + ); + await Future.delayed(const Duration(milliseconds: 40)); + + expect(store.maxActive, 1, reason: 'the writes must be serialized'); + expect(store.stored, contains('"1:Failed"')); + expect(store.stored, contains('"2:Failed"')); + expect(store.writes.last, store.stored); + }); + }); + + group('the platform seam', () { + test('the non-web bridge reports unsupported honestly', () async { + final bridge = createNotificationBridge(); + expect(bridge.environment().supported, isFalse); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(notify.dispose); + await notify.load(); + expect(notify.permission, NotificationPermissionState.unsupported); + expect( + bridge.show( + const NotificationMessage( + runId: 1, + title: 'A run failed', + body: 'release', + tag: '1:Failed', + ), + ), + isFalse, + ); + }); + }); +} + +/// A store whose writes take a tick, so a racing implementation would overlap +/// them and the last value to land would be the older snapshot. +class _SlowStore implements NotificationStore { + String? stored; + int active = 0; + int maxActive = 0; + final List writes = []; + + @override + Future read() async => stored; + + @override + Future write(String value) async { + active++; + if (active > maxActive) maxActive = active; + await Future.delayed(const Duration(milliseconds: 2)); + stored = value; + writes.add(value); + active--; + return true; + } +} + +class _ThrowingBridge implements NotificationBridge { + @override + NotificationEnvironment environment() => const NotificationEnvironment( + supported: true, + secureContext: true, + permission: 'granted', + ); + + @override + Future requestPermission() async => 'granted'; + + @override + bool show(NotificationMessage message, {void Function()? onTap}) => + throw StateError('the browser refused to construct a notification'); +} diff --git a/app/test/features/attention/notify/notification_ledger_test.dart b/app/test/features/attention/notify/notification_ledger_test.dart new file mode 100644 index 00000000..9dde970a --- /dev/null +++ b/app/test/features/attention/notify/notification_ledger_test.dart @@ -0,0 +1,143 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/attention/notify/notification_ledger.dart'; + +import 'notification_test_support.dart'; + +void main() { + group('the identity is the run and kind', () { + test('two failures of one run are the same announced state', () { + final first = transitionFor(7, finishedAt: '2026-10-22T09:10:00Z'); + final second = transitionFor(7, finishedAt: '2026-10-22T11:30:00Z'); + expect(notificationIdentity(first), '7:Failed'); + expect(notificationIdentity(second), '7:Failed'); + }); + + test('a waiting run needs no finish time to have an identity', () { + final entry = transitionFor(7, status: 'waiting', finishedAt: ''); + expect(notificationIdentity(entry), '7:Decision'); + }); + + test('the kind separates a decision from a failure of one run', () { + expect( + notificationIdentity(transitionFor(7)), + isNot(notificationIdentity(transitionFor(7, status: 'waiting'))), + ); + }); + }); + + group('the qualifying set is the attention surface\'s own keys', () { + test('only failed and human-waiting runs qualify', () { + expect( + notificationQualifyingKeys([ + runSummary(1, 'failed'), + runSummary(2, 'waiting'), + runSummary(3, 'running'), + runSummary(4, 'succeeded'), + runSummary(5, 'queued'), + runSummary(6, 'waiting', exportPending: 2), + ]), + {'1:Failed', '2:Decision'}, + ); + }); + + test('a duplicate row and a malformed id add nothing', () { + expect( + notificationQualifyingKeys([ + runSummary(1, 'failed'), + runSummary(1, 'failed'), + {'id': 0, 'status': 'failed'}, + {'id': 'not a run', 'status': 'failed'}, + ]), + {'1:Failed'}, + ); + expect(notificationQualifyingKeys(null), isEmpty); + }); + + test('the frame key form is read too', () { + expect(notificationQualifyingKeys([runFrame(9, 'failed')]), {'9:Failed'}); + }); + }); + + group('the ledger records identities', () { + test('recording is idempotent and never mutates the original', () { + const base = NotificationLedger(); + final once = base.recording('7:Failed'); + final twice = once.recording('7:Failed'); + expect(base.notified, isEmpty); + expect(once.hasNotified('7:Failed'), isTrue); + expect(twice.notified, {'7:Failed'}); + }); + + test('asked is carried without touching the identities', () { + final asked = const NotificationLedger(notified: {'a'}).withAsked(true); + expect(asked.asked, isTrue); + expect(asked.notified, {'a'}); + }); + }); + + group('pruning keeps only the current qualifying run', () { + test('a run that left the state is forgotten; asked survives', () { + final ledger = const NotificationLedger( + notified: {'7:Decision', '8:Failed'}, + ).withAsked(true); + final pruned = ledger.pruning({'8:Failed'}); + expect(pruned.notified, {'8:Failed'}); + expect(pruned.asked, isTrue); + }); + + test('nothing to drop returns the same ledger', () { + const ledger = NotificationLedger(notified: {'7:Failed'}); + expect(identical(ledger.pruning({'7:Failed'}), ledger), isTrue); + }); + + test('a timestamped identity from an older build is dropped', () { + final old = decodeNotificationLedger( + '{"asked":false,"notified":["7:Decision@2026-10-22T11:00:00.000"]}', + ); + expect(old.notified, hasLength(1)); + expect(old.pruning({'7:Decision'}).notified, isEmpty); + }); + }); + + group('persistence is total', () { + test('a round trip keeps the asked flag and the identities', () { + final ledger = const NotificationLedger( + notified: {'b', 'a'}, + ).withAsked(true); + final decoded = decodeNotificationLedger( + encodeNotificationLedger(ledger), + ); + expect(decoded.asked, isTrue); + expect(decoded.notified, {'a', 'b'}); + }); + + test('an unchanged ledger always encodes to the same bytes', () { + final first = encodeNotificationLedger( + const NotificationLedger(notified: {'b', 'a'}), + ); + final second = encodeNotificationLedger( + const NotificationLedger(notified: {'a', 'b'}), + ); + expect(first, second); + }); + + test('blank, malformed and wrong-typed values never throw', () { + expect(decodeNotificationLedger(null).notified, isEmpty); + expect(decodeNotificationLedger('').asked, isFalse); + expect(decodeNotificationLedger('not json').notified, isEmpty); + expect(decodeNotificationLedger('[]').notified, isEmpty); + expect(decodeNotificationLedger('"text"').notified, isEmpty); + expect( + decodeNotificationLedger( + '{"asked":"yes","notified":[1,null,"a",""]}', + ).notified, + {'a'}, + ); + expect( + decodeNotificationLedger('{"asked":"yes"}').asked, + isFalse, + reason: 'only a real true counts as asked', + ); + }); + }); +} diff --git a/app/test/features/attention/notify/notification_models_test.dart b/app/test/features/attention/notify/notification_models_test.dart new file mode 100644 index 00000000..90244413 --- /dev/null +++ b/app/test/features/attention/notify/notification_models_test.dart @@ -0,0 +1,158 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/attention/domain/attention_models.dart'; +import 'package:pipelines_app/features/attention/notify/notification_models.dart'; + +NotificationEnvironment _env({ + bool supported = true, + bool secure = true, + String permission = 'default', +}) => NotificationEnvironment( + supported: supported, + secureContext: secure, + permission: permission, +); + +void main() { + group('permission state is the platform\'s own answer', () { + test('an unsupported API and an insecure page win over the word', () { + expect( + notificationStateOf(_env(supported: false, permission: 'granted')), + NotificationPermissionState.unsupported, + ); + expect( + notificationStateOf(_env(secure: false, permission: 'granted')), + NotificationPermissionState.needsSecureContext, + ); + }); + + test('granted is never assumed from an unrecognised word', () { + expect( + notificationStateOf(_env(permission: 'prompt')), + NotificationPermissionState.notRequested, + ); + expect( + notificationStateOf(_env(permission: '')), + NotificationPermissionState.notRequested, + ); + expect( + notificationStateOf(_env(permission: 'granted')), + NotificationPermissionState.granted, + ); + expect( + notificationStateOf(_env(permission: 'denied')), + NotificationPermissionState.denied, + ); + }); + + test('each state carries the browser model\'s own wire word', () { + expect(NotificationPermissionState.unsupported.wireName, 'unsupported'); + expect( + NotificationPermissionState.needsSecureContext.wireName, + 'insecure', + ); + expect(NotificationPermissionState.notRequested.wireName, 'default'); + expect(NotificationPermissionState.granted.wireName, 'granted'); + expect(NotificationPermissionState.denied.wireName, 'denied'); + }); + }); + + group('the permission view', () { + test('only a still-undecided page can request', () { + final view = notificationPermissionView( + NotificationPermissionState.notRequested, + ); + expect(view.canRequest, isTrue); + expect(view.actionLabel, notificationRequestLabel); + expect(view.body, notificationDefaultCopy); + + for (final state in [ + NotificationPermissionState.unsupported, + NotificationPermissionState.needsSecureContext, + NotificationPermissionState.granted, + NotificationPermissionState.denied, + ]) { + final other = notificationPermissionView(state); + expect(other.canRequest, isFalse, reason: '$state'); + expect(other.actionLabel, isNull, reason: '$state'); + } + }); + + test('asked only changes the undecided wording', () { + expect( + notificationPermissionView( + NotificationPermissionState.notRequested, + asked: true, + ).body, + notificationDefaultAskedCopy, + ); + expect( + notificationPermissionView( + NotificationPermissionState.denied, + asked: true, + ).body, + notificationDeniedCopy, + ); + }); + + test('every unavailable state names the in-app channel', () { + for (final state in [ + NotificationPermissionState.unsupported, + NotificationPermissionState.needsSecureContext, + NotificationPermissionState.denied, + ]) { + expect( + notificationPermissionView(state).body, + contains('in-app Needs you surface'), + reason: '$state', + ); + } + }); + }); + + group('notification content is the entry\'s own words', () { + test('the headline is the kind, nothing invented', () { + expect( + notificationAlertTitle(AttentionKind.decision), + 'A run needs your decision', + ); + expect(notificationAlertTitle(AttentionKind.failed), 'A run failed'); + }); + + test('the body is the run label then its pipeline', () { + final entry = attentionEntryFor({ + 'id': 7, + 'name': 'nightly-audit', + 'title': 'Nightly audit', + 'status': 'failed', + 'diagnostic': 'Stage 3 stopped', + 'created_at': '2026-10-22T09:00:00Z', + 'finished_at': '2026-10-22T09:10:00Z', + })!; + expect( + notificationAlertBody(entry), + 'Nightly audit \u00b7 nightly-audit', + ); + }); + + test('a blank or equal pipeline is never repeated', () { + final untitled = attentionEntryFor({ + 'id': 7, + 'name': 'release', + 'status': 'failed', + 'created_at': '2026-10-22T09:00:00Z', + 'finished_at': '2026-10-22T09:10:00Z', + })!; + expect(notificationAlertBody(untitled), 'release'); + + final nameless = attentionEntryFor({ + 'id': 8, + 'name': '', + 'title': 'A title', + 'status': 'failed', + 'created_at': '2026-10-22T09:00:00Z', + 'finished_at': '2026-10-22T09:10:00Z', + })!; + expect(notificationAlertBody(nameless), 'A title'); + }); + }); +} diff --git a/app/test/features/attention/notify/notification_permission_test.dart b/app/test/features/attention/notify/notification_permission_test.dart new file mode 100644 index 00000000..4feff63b --- /dev/null +++ b/app/test/features/attention/notify/notification_permission_test.dart @@ -0,0 +1,103 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/attention/notify/notification_controller.dart'; +import 'package:pipelines_app/features/attention/notify/notification_models.dart'; +import 'package:pipelines_app/features/attention/notify/notification_store.dart'; + +import 'notification_test_support.dart'; + +void main() { + group('permission is only ever the platform\'s answer', () { + test('an unsupported platform is never asked and never posts', () async { + final bridge = FakeNotificationBridge(supported: false); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(notify.dispose); + await notify.load(); + expect(notify.permission, NotificationPermissionState.unsupported); + + expect( + await notify.requestPermission(), + NotificationPermissionState.unsupported, + ); + expect(bridge.requests, 0); + expect( + notify.publishTransitions([transitionFor(1)], qualifying: {'1:Failed'}), + 0, + ); + expect(bridge.shown, isEmpty); + }); + + test('an insecure page reports needsSecureContext', () async { + final bridge = FakeNotificationBridge(secureContext: false); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(notify.dispose); + await notify.load(); + expect(notify.permission, NotificationPermissionState.needsSecureContext); + await notify.requestPermission(); + expect(bridge.requests, 0); + }); + + test('a default page is asked once and follows the real answer', () async { + final store = MemoryNotificationStore(); + final bridge = FakeNotificationBridge(answer: 'granted'); + final notify = NotificationController(store: store, bridge: bridge); + addTearDown(notify.dispose); + await notify.load(); + expect(notify.permission, NotificationPermissionState.notRequested); + expect(notify.canNotify, isFalse); + + final state = await notify.requestPermission(); + expect(bridge.requests, 1); + expect(state, NotificationPermissionState.granted); + expect(notify.canNotify, isTrue); + expect(notify.asked, isTrue); + await settle(); + expect(store.stored, contains('"asked":true')); + }); + + test('a denied answer is never re-prompted', () async { + final bridge = FakeNotificationBridge(permission: 'denied'); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(notify.dispose); + await notify.load(); + expect(notify.permission, NotificationPermissionState.denied); + + expect( + await notify.requestPermission(), + NotificationPermissionState.denied, + ); + expect(bridge.requests, 0); + expect( + notify.publishTransitions([transitionFor(1)], qualifying: {'1:Failed'}), + 0, + ); + expect(bridge.shown, isEmpty); + }); + + test( + 'a prompt that grants nothing keeps the honest default wording', + () async { + final bridge = FakeNotificationBridge(answer: 'default'); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(notify.dispose); + await notify.load(); + + final state = await notify.requestPermission(); + expect(state, NotificationPermissionState.notRequested); + expect(notify.asked, isTrue); + expect(notify.canNotify, isFalse); + }, + ); + }); +} diff --git a/app/test/features/attention/notify/notification_reentry_test.dart b/app/test/features/attention/notify/notification_reentry_test.dart new file mode 100644 index 00000000..baece833 --- /dev/null +++ b/app/test/features/attention/notify/notification_reentry_test.dart @@ -0,0 +1,93 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/attention/notify/notification_controller.dart'; +import 'package:pipelines_app/features/attention/notify/notification_store.dart'; + +import 'notification_test_support.dart'; + +/// A run that leaves a qualifying state and enters it again is a new event. +/// +/// A waiting run has no `finished_at`, and its creation time never changes, so +/// both gates of one run carry exactly the same timestamps. These tests pin the +/// behaviour that was silently dropped when the identity included that marker. +void main() { + test('a second decision gate of the same run notifies again', () async { + final attention = attentionController(); + final bridge = FakeNotificationBridge(permission: 'granted'); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(attention.dispose); + addTearDown(notify.dispose); + await attention.load(); + await notify.load(); + + attention.seedRows([runSummary(7, 'running')]); + attention.observeFrame(runFrame(7, 'waiting', finishedAt: '')); + expect(publish(notify, attention), 1); + expect(bridge.shown.single.tag, '7:Decision'); + + attention.observeFrame(runFrame(7, 'running')); + expect(publish(notify, attention), 0); + + attention.observeFrame(runFrame(7, 'waiting', finishedAt: '')); + expect(attention.transitions, hasLength(2)); + expect(publish(notify, attention), 1); + expect(bridge.shown, hasLength(2)); + // The browser coalesces by run+kind, so both alerts share one tag. + expect(bridge.shown.map((m) => m.tag).toSet(), {'7:Decision'}); + }); + + test( + 'a second decision gate notifies even without the leaving publish', + () async { + final attention = attentionController(); + final bridge = FakeNotificationBridge(permission: 'granted'); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(attention.dispose); + addTearDown(notify.dispose); + await attention.load(); + await notify.load(); + + attention.seedRows([runSummary(7, 'running')]); + attention.observeFrame(runFrame(7, 'waiting', finishedAt: '')); + expect(publish(notify, attention), 1); + + // The caller misses the frame that leaves the state; the detector still + // creates a new instance for the next gate, so it must notify again. + attention.observeFrame(runFrame(7, 'running')); + attention.observeFrame(runFrame(7, 'waiting', finishedAt: '')); + expect(publish(notify, attention), 1); + expect(bridge.shown, hasLength(2)); + expect(bridge.shown.map((m) => m.tag).toSet(), {'7:Decision'}); + }, + ); + + test('a coalesced backlog of two gates notifies once', () async { + final attention = attentionController(); + final bridge = FakeNotificationBridge(permission: 'granted'); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + addTearDown(attention.dispose); + addTearDown(notify.dispose); + await attention.load(); + await notify.load(); + + attention.seedRows([runSummary(7, 'running')]); + attention.observeFrame(runFrame(7, 'waiting', finishedAt: '')); + attention.observeFrame(runFrame(7, 'running')); + attention.observeFrame(runFrame(7, 'waiting', finishedAt: '')); + expect(attention.transitions, hasLength(2)); + + // Both gates were folded before the caller published; the current state is + // what the operator should be told about, once. + expect(publish(notify, attention), 1); + expect(bridge.shown, hasLength(1)); + expect(bridge.shown.single.tag, '7:Decision'); + }); +} diff --git a/app/test/features/attention/notify/notification_test_support.dart b/app/test/features/attention/notify/notification_test_support.dart new file mode 100644 index 00000000..8e0db312 --- /dev/null +++ b/app/test/features/attention/notify/notification_test_support.dart @@ -0,0 +1,136 @@ +import 'package:pipelines_app/features/attention/domain/attention_models.dart'; +import 'package:pipelines_app/features/attention/domain/attention_transitions.dart'; +import 'package:pipelines_app/features/attention/notify/notification_bridge.dart'; +import 'package:pipelines_app/features/attention/notify/notification_controller.dart'; +import 'package:pipelines_app/features/attention/notify/notification_ledger.dart'; +import 'package:pipelines_app/features/attention/notify/notification_models.dart'; +import 'package:pipelines_app/features/attention/runtime/attention_controller.dart'; +import 'package:pipelines_app/features/attention/runtime/attention_store.dart'; + +/// The fixed local time the attention tests order and window by. +final attentionNow = DateTime(2026, 10, 22, 12); + +String at(Duration before) => attentionNow.subtract(before).toIso8601String(); + +/// One run summary, built exactly as the runs list holds it. +Map runSummary( + int id, + String status, { + String name = 'release', + String? title, + Duration age = const Duration(hours: 1), + String diagnostic = '', + Object? exportPending, + Map extra = const {}, +}) => { + 'id': id, + 'name': name, + 'title': title ?? 'Run $id', + 'status': status, + 'diagnostic': diagnostic, + 'created_at': at(age), + // The server leaves finished_at empty for a waiting run (and for one still in + // flight); only a settled run carries a finish time. + 'finished_at': status == 'waiting' || status == 'running' + ? '' + : at(age - const Duration(minutes: 5)), + 'export_pending_sequence': ?exportPending, + ...extra, +}; + +/// One qualifying pushed frame for a run, as `run_event` carries it. +/// +/// A waiting or running frame has no `finished_at`, matching the server; pass +/// [finishedAt] only to describe a settled run. +Map runFrame( + int id, + String status, { + String name = 'release', + String? title, + String diagnostic = '', + String? finishedAt, +}) => { + 'type': 'run_event', + 'run_id': id, + 'name': name, + 'title': title ?? 'Run $id', + 'status': status, + 'diagnostic': diagnostic, + 'created_at': at(const Duration(hours: 1)), + 'finished_at': + finishedAt ?? + (status == 'waiting' || status == 'running' + ? '' + : at(const Duration(minutes: 1))), +}; + +/// One transition for a run that just entered [status], for batch tests. +AttentionTransition transitionFor( + int id, { + String status = 'failed', + String name = 'release', + String? title, + String? finishedAt, +}) => AttentionTransition( + attentionEntryFor( + runFrame(id, status, name: name, title: title, finishedAt: finishedAt), + )!, +); + +/// Let the controller's fire-and-forget ledger write land. +Future settle() => Future.delayed(Duration.zero); + +/// Publish exactly the way the manager wires it: the accumulated transitions, +/// the current rows and the dismissed set from the same attention snapshot. +int publish(NotificationController notify, AttentionController attention) => + notify.publishTransitions( + attention.transitions, + qualifying: notificationQualifyingKeys(attention.rows), + dismissed: attention.dismissed, + ); + +AttentionController attentionController() => + AttentionController(store: MemoryAttentionStore(), now: () => attentionNow); + +/// A bridge whose answers are set explicitly, so every permission path is +/// exercised without a browser. It records what the controller asked for. +class FakeNotificationBridge implements NotificationBridge { + FakeNotificationBridge({ + this.supported = true, + this.secureContext = true, + this.permission = 'default', + this.answer = 'granted', + this.accepts = true, + }); + + bool supported; + bool secureContext; + String permission; + String answer; + bool accepts; + + int requests = 0; + final List shown = []; + final List taps = []; + + @override + NotificationEnvironment environment() => NotificationEnvironment( + supported: supported, + secureContext: secureContext, + permission: permission, + ); + + @override + Future requestPermission() async { + requests++; + permission = answer; + return answer; + } + + @override + bool show(NotificationMessage message, {void Function()? onTap}) { + shown.add(message); + taps.add(onTap); + return accepts; + } +} diff --git a/app/test/features/attention/ui/notification_permission_tile_test.dart b/app/test/features/attention/ui/notification_permission_tile_test.dart new file mode 100644 index 00000000..b764b941 --- /dev/null +++ b/app/test/features/attention/ui/notification_permission_tile_test.dart @@ -0,0 +1,140 @@ +import 'package:flutter/material.dart'; +import 'package:flutter/rendering.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/attention/notify/notification_models.dart'; +import 'package:pipelines_app/features/attention/ui/notification_permission_tile.dart'; + +import 'needs_you_test_support.dart'; + +/// The tile inside a normal page, so both native hosts can draw it. The page +/// scrolls like the Settings list does, so the tile is never given a fixed +/// height to overflow. +Widget _page({ + required NotificationPermissionState state, + bool cupertino = false, + bool asked = false, + VoidCallback? onRequest, +}) => attentionApp( + Scaffold( + body: SingleChildScrollView( + child: NotificationPermissionTile( + state: state, + asked: asked, + onRequest: onRequest, + ), + ), + ), + cupertino: cupertino, +); + +void _noop() {} + +void main() { + for (final native in [false, true]) { + final host = native ? 'Cupertino' : 'Material'; + + testWidgets('$host shows the state\'s own honest copy', (tester) async { + final cases = { + NotificationPermissionState.unsupported: notificationUnsupportedCopy, + NotificationPermissionState.needsSecureContext: + notificationInsecureCopy, + NotificationPermissionState.granted: notificationGrantedCopy, + NotificationPermissionState.denied: notificationDeniedCopy, + NotificationPermissionState.notRequested: notificationDefaultCopy, + }; + for (final entry in cases.entries) { + await tester.pumpWidget( + _page(state: entry.key, cupertino: native, onRequest: _noop), + ); + expect(find.text(notificationSectionTitle), findsOneWidget); + expect(find.text(notificationRationale), findsOneWidget); + expect(find.text(entry.value), findsOneWidget, reason: '${entry.key}'); + expect( + find.byKey(notificationEnableKey), + entry.key == NotificationPermissionState.notRequested + ? findsOneWidget + : findsNothing, + reason: '${entry.key}', + ); + } + }); + + testWidgets('$host shows the asked wording without an action', ( + tester, + ) async { + await tester.pumpWidget( + _page( + state: NotificationPermissionState.notRequested, + asked: true, + cupertino: native, + ), + ); + expect(find.text(notificationDefaultAskedCopy), findsOneWidget); + expect(find.text(notificationDefaultCopy), findsNothing); + }); + + testWidgets('$host Enable runs the explicit request', (tester) async { + var requested = 0; + await tester.pumpWidget( + _page( + state: NotificationPermissionState.notRequested, + cupertino: native, + onRequest: () => requested++, + ), + ); + await tester.tap(find.byKey(notificationEnableKey)); + await tester.pump(); + expect(requested, 1); + }); + + testWidgets('$host tile wraps at 320 logical px and 2x in dark', ( + tester, + ) async { + tester.view.devicePixelRatio = 2; + tester.view.physicalSize = const Size(640, 1280); + addTearDown(tester.view.resetPhysicalSize); + addTearDown(tester.view.resetDevicePixelRatio); + + // The undecided state is the hardest: it carries the Enable action as well + // as the longest copy, so the section title must still have room to read. + await tester.pumpWidget( + attentionApp( + Scaffold( + body: SingleChildScrollView( + child: NotificationPermissionTile( + state: NotificationPermissionState.notRequested, + onRequest: _noop, + ), + ), + ), + cupertino: native, + dark: true, + textScale: 2, + ), + ); + expect(tester.takeException(), isNull); + + final title = tester.renderObject( + find.text(notificationSectionTitle), + ); + // Cupertino's list tile deliberately caps its title at one line; the + // defect this guards is the title being squeezed to a single glyph by the + // action sharing the row, so its width is the meaningful check. + expect( + title.size.width, + greaterThan(100), + reason: 'the action must not squeeze the section title to one glyph', + ); + final body = tester.renderObject( + find.text(notificationDefaultCopy), + ); + expect(body.didExceedMaxLines, isFalse); + expect(find.byKey(notificationEnableKey), findsOneWidget); + + final rect = tester.getRect(find.byKey(notificationStateKey)); + expect(rect.left, greaterThanOrEqualTo(0)); + expect(rect.right, lessThanOrEqualTo(320)); + expect(tester.takeException(), isNull); + }); + } +} diff --git a/app/tool/notification_probe.dart b/app/tool/notification_probe.dart new file mode 100644 index 00000000..ff88ccb2 --- /dev/null +++ b/app/tool/notification_probe.dart @@ -0,0 +1,291 @@ +import 'dart:js_interop'; +import 'dart:js_interop_unsafe'; + +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; + +import 'package:pipelines_app/features/attention/domain/attention_models.dart'; +import 'package:pipelines_app/features/attention/notify/notification_bridge.dart'; +import 'package:pipelines_app/features/attention/notify/notification_controller.dart'; +import 'package:pipelines_app/features/attention/notify/notification_ledger.dart'; +import 'package:pipelines_app/features/attention/notify/notification_models.dart'; +import 'package:pipelines_app/features/attention/notify/notification_store.dart'; +import 'package:pipelines_app/features/attention/runtime/attention_controller.dart'; +import 'package:pipelines_app/features/attention/runtime/attention_store.dart'; +import 'package:pipelines_app/features/attention/ui/notification_permission_tile.dart'; + +/// Browser capture entrypoint for the notification capability. +/// +/// It drives the real [NotificationController] over the real web bridge, so a +/// browser drive can prove the seed is silent, one live transition raises +/// exactly one notification with the entry's own words and run+kind identity, a +/// dismissed or replayed transition raises none, a second decision gate of one +/// run raises a fresh notification, and the Settings tile reads honestly in +/// every state on both hosts. Nothing here opens a socket or touches real +/// operator data; the store is in memory. +void main() { + final params = Uri.base.queryParameters; + final mode = params['mode'] ?? 'transition'; + final cupertino = params['host'] == 'cupertino'; + final scale = double.tryParse(params['scale'] ?? '') ?? 1; + final brightness = params['theme'] == 'light' + ? Brightness.light + : Brightness.dark; + Widget scaled(BuildContext context, Widget? app) => MediaQuery( + data: MediaQuery.of(context).copyWith(textScaler: TextScaler.linear(scale)), + child: app!, + ); + final home = switch (mode) { + 'tiles' => const _TileGallery(), + 'tile' => _SingleTile(state: _stateOf(params['state'])), + _ => _NotificationProbe(mode: mode), + }; + if (cupertino) { + runApp( + CupertinoApp( + theme: CupertinoThemeData(brightness: brightness), + builder: scaled, + home: home, + ), + ); + return; + } + runApp( + MaterialApp( + theme: ThemeData( + platform: TargetPlatform.android, + brightness: brightness, + ), + builder: scaled, + home: home, + ), + ); +} + +/// The report the browser drive reads, as a plain JS string. +void _publishReport(String value) => + globalContext.setProperty('__probeReport'.toJS, value.toJS); + +/// The permission state named by a `state` query parameter, defaulting to the +/// undecided one. +NotificationPermissionState _stateOf(String? name) { + for (final state in NotificationPermissionState.values) { + if (state.wireName == name) return state; + } + return NotificationPermissionState.notRequested; +} + +String _at(Duration before) => + DateTime.now().toUtc().subtract(before).toIso8601String(); + +Map _summary( + int id, + String status, { + String name = 'release', + String? title, + String diagnostic = '', +}) => { + 'id': id, + 'name': name, + 'title': title ?? 'Run $id', + 'status': status, + 'diagnostic': diagnostic, + 'created_at': _at(const Duration(hours: 1)), + // The server leaves finished_at empty while a run is in flight or waiting. + 'finished_at': status == 'waiting' || status == 'running' + ? '' + : _at(const Duration(minutes: 55)), +}; + +Map _frame( + int id, + String status, { + String name = 'release', + String? title, + String diagnostic = '', +}) => { + 'type': 'run_event', + 'run_id': id, + 'name': name, + 'title': title ?? 'Run $id', + 'status': status, + 'diagnostic': diagnostic, + 'finished_at': status == 'waiting' || status == 'running' + ? '' + : _at(const Duration(minutes: 1)), +}; + +/// Publish exactly as the manager wires it: the accumulated transitions and the +/// current qualifying keys from the same attention snapshot. +int _publish(NotificationController notify, AttentionController attention) => + notify.publishTransitions( + attention.transitions, + qualifying: notificationQualifyingKeys(attention.rows), + dismissed: attention.dismissed, + ); + +/// Runs one notification scenario against the real bridge, then reports it and +/// draws the live permission tile underneath. +class _NotificationProbe extends StatefulWidget { + const _NotificationProbe({required this.mode}); + + final String mode; + + @override + State<_NotificationProbe> createState() => _NotificationProbeState(); +} + +class _NotificationProbeState extends State<_NotificationProbe> { + String _report = 'running'; + NotificationPermissionState _permission = + NotificationPermissionState.unsupported; + bool _asked = false; + + @override + void initState() { + super.initState(); + WidgetsBinding.instance.addPostFrameCallback((_) => _run()); + } + + Future _run() async { + final bridge = createNotificationBridge(); + final notify = NotificationController( + store: MemoryNotificationStore(), + bridge: bridge, + ); + await notify.load(); + final attention = AttentionController(store: MemoryAttentionStore()); + await attention.load(); + + switch (widget.mode) { + case 'seed': + attention.seedRows([ + _summary(1, 'failed', diagnostic: 'Stage 3 stopped'), + _summary(2, 'waiting'), + ]); + _publish(notify, attention); + case 'dismissed': + attention.seedRows([_summary(1, 'running')]); + await attention.dismiss(attentionEntryFor(_summary(1, 'failed'))!); + attention.observeFrame(_frame(1, 'failed')); + _publish(notify, attention); + case 'reconnect': + attention.seedRows([_summary(1, 'running')]); + attention.observeFrame(_frame(1, 'failed')); + _publish(notify, attention); + attention.resetForReconnect(); + attention.seedRows([_summary(1, 'failed')], reconnect: true); + _publish(notify, attention); + attention.observeFrame(_frame(1, 'failed')); + _publish(notify, attention); + case 'secondgate': + // A waiting run has no finished_at, so two gates of one run carry the + // same timestamps; leaving the state is what makes the second new. + attention.seedRows([_summary(7, 'running')]); + attention.observeFrame(_frame(7, 'waiting')); + _publish(notify, attention); + attention.observeFrame(_frame(7, 'running')); + _publish(notify, attention); + attention.observeFrame(_frame(7, 'waiting')); + _publish(notify, attention); + case 'denied': + case 'unsupported': + case 'default': + attention.seedRows([_summary(1, 'running')]); + attention.observeFrame(_frame(1, 'failed')); + _publish(notify, attention); + default: + attention.seedRows([_summary(1, 'running', name: 'nightly')]); + attention.observeFrame( + _frame( + 1, + 'failed', + name: 'nightly', + title: 'Nightly audit', + diagnostic: 'Stage 3 stopped', + ), + ); + _publish(notify, attention); + } + + if (!mounted) return; + final report = + 'mode=${widget.mode} posted=${notify.postedCount} ' + 'state=${notify.permission.wireName} asked=${notify.asked} ' + 'notified=${notify.notified.length}'; + _publishReport(report); + setState(() { + _report = report; + _permission = notify.permission; + _asked = notify.asked; + }); + notify.dispose(); + attention.dispose(); + } + + @override + Widget build(BuildContext context) { + return Scaffold( + body: SafeArea( + child: ListView( + padding: const EdgeInsets.all(16), + children: [ + Text(_report), + const SizedBox(height: 16), + NotificationPermissionTile( + state: _permission, + asked: _asked, + onRequest: () {}, + ), + ], + ), + ), + ); + } +} + +/// One permission state on its own, so each can be captured and read at the +/// hardest width and text scale. +class _SingleTile extends StatelessWidget { + const _SingleTile({required this.state}); + + final NotificationPermissionState state; + + @override + Widget build(BuildContext context) { + return Scaffold( + body: SafeArea( + child: SingleChildScrollView( + padding: const EdgeInsets.all(16), + child: NotificationPermissionTile(state: state, onRequest: () {}), + ), + ), + ); + } +} + +/// Every permission state at once, so both hosts can be captured and read in +/// one page without touching a real permission. +class _TileGallery extends StatelessWidget { + const _TileGallery(); + + @override + Widget build(BuildContext context) { + return Scaffold( + body: SafeArea( + child: SingleChildScrollView( + padding: const EdgeInsets.all(16), + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + for (final state in NotificationPermissionState.values) ...[ + Text(state.wireName), + NotificationPermissionTile(state: state, onRequest: () {}), + ], + ], + ), + ), + ), + ); + } +} diff --git a/app/tool/notification_probe.mjs b/app/tool/notification_probe.mjs new file mode 100644 index 00000000..1487c7ac --- /dev/null +++ b/app/tool/notification_probe.mjs @@ -0,0 +1,314 @@ +// Real-browser acceptance for the attention notification capability. +// +// flutter build web -t tool/notification_probe.dart -o build/notification_probe_web +// OPENCODE_ARTIFACT_DIR= node tool/notification_probe.mjs +// +// The page is served from an isolated loopback server. `window.Notification` is +// replaced with a recording spy before the app loads, and the real browser +// permission is granted (or denied) through CDP, so the drive proves the real +// bridge's behaviour: the initial seed raises nothing, one live transition +// raises exactly one notification with the entry's own words and run+kind +// identity, a dismissed transition and a reconnect replay raise none, a second +// decision gate of one run raises a fresh notification (the waiting shape has no +// finished_at), and the Settings tile reads honestly in every state on both +// hosts at 320 logical px and 2x text. One PNG is written per captured state. +import { createServer } from 'node:http'; +import { spawn } from 'node:child_process'; +import { once } from 'node:events'; +import { existsSync } from 'node:fs'; +import { setTimeout as delay } from 'node:timers/promises'; +import { join, extname, resolve, sep } from 'node:path'; +import { tmpdir } from 'node:os'; +import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'; + +const root = resolve(process.env.PROBE_WEB_ROOT ?? 'build/notification_probe_web'); +const artifactDir = process.env.OPENCODE_ARTIFACT_DIR; +if (!artifactDir) throw new Error('Set OPENCODE_ARTIFACT_DIR for the probe captures'); +await mkdir(artifactDir, { recursive: true }); +const defaultChrome = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'; +const chromePath = process.env.CHROME_PATH ?? defaultChrome; +if (!existsSync(chromePath)) throw new Error(`Chrome not found at ${chromePath}; set CHROME_PATH`); + +const mime = { + '.html': 'text/html', + '.js': 'text/javascript', + '.json': 'application/json', + '.wasm': 'application/wasm', + '.png': 'image/png', + '.ico': 'image/x-icon', +}; +const server = createServer(async (req, res) => { + try { + const path = resolve(root, '.' + decodeURIComponent(new URL(req.url, 'http://localhost').pathname)); + if (path !== root && !path.startsWith(root + sep)) return res.writeHead(403).end(); + const filePath = path === root || path.endsWith('/') ? join(path, 'index.html') : path; + const file = await readFile(filePath); + res.writeHead(200, { 'content-type': mime[extname(filePath)] ?? 'application/octet-stream' }).end(file); + } catch { + res.writeHead(404).end('not found'); + } +}); +server.listen(0, '127.0.0.1'); +await once(server, 'listening'); +const port = server.address().port; +const origin = `http://127.0.0.1:${port}`; + +// The spy is installed before every document, so the app only ever sees it. It +// delegates `permission` to the real constructor (which CDP granted or denied) +// and records each `new Notification(...)` call. +const spy = `(() => { + const mode = new URLSearchParams(location.search).get('mode') || ''; + window.__notifications = []; + window.__probeReport = ''; + if (mode === 'unsupported') { window.Notification = undefined; return; } + const Real = window.Notification; + function Spy(title, options) { + window.__notifications.push({ + title: String(title ?? ''), + body: String((options && options.body) || ''), + tag: String((options && options.tag) || ''), + }); + return { onclick: null, close() {} }; + } + Object.defineProperty(Spy, 'permission', { + get: () => (Real ? Real.permission : 'granted'), + }); + Spy.requestPermission = () => Promise.resolve(Spy.permission); + window.Notification = Spy; +})();`; + +const profile = await mkdtemp(join(tmpdir(), 'notification-chrome-')); +const chrome = spawn( + chromePath, + [ + '--headless=new', + '--no-first-run', + '--no-default-browser-check', + '--disable-gpu', + '--remote-debugging-port=0', + `--user-data-dir=${profile}`, + 'about:blank', + ], + { stdio: ['ignore', 'ignore', 'pipe'] }, +); +let stderr = ''; +chrome.stderr.on('data', (data) => { stderr += data; }); +const waitFor = async (check) => { + for (let i = 0; i < 120; i++) { + const value = await check(); + if (value) return value; + await delay(100); + } + throw new Error(`Timed out waiting for Chrome DevTools\n${stderr.slice(-1200)}`); +}; + +let ws; +try { + const endpoint = await waitFor(() => stderr.match(/DevTools listening on (ws:\/\/[^\s]+)/)?.[1]); + ws = new WebSocket(endpoint); + await once(ws, 'open'); + let id = 0; + const pending = new Map(); + ws.addEventListener('message', (event) => { + const message = JSON.parse(event.data); + if (message.id && pending.has(message.id)) { + pending.get(message.id)(message); + pending.delete(message.id); + } + }); + const send = (method, params = {}, sessionId) => + new Promise((resolveCall, rejectCall) => { + const callId = ++id; + pending.set(callId, (message) => { + if (message.error) rejectCall(new Error(`${method}: ${message.error.message}`)); + else resolveCall(message.result); + }); + ws.send(JSON.stringify({ id: callId, method, params, ...(sessionId ? { sessionId } : {}) })); + }); + + const target = (await send('Target.createTarget', { url: 'about:blank' })).targetId; + const session = (await send('Target.attachToTarget', { targetId: target, flatten: true })).sessionId; + await send('Page.enable', {}, session); + await send('Runtime.enable', {}, session); + await send('Page.addScriptToEvaluateOnNewDocument', { source: spy }, session); + + const evaluate = async (expression) => { + const response = await send( + 'Runtime.evaluate', + { expression, returnByValue: true, awaitPromise: true }, + session, + ); + if (response.exceptionDetails) { + throw new Error(`Runtime.evaluate failed: ${JSON.stringify(response.exceptionDetails)}`); + } + return response.result?.value; + }; + const semantics = () => evaluate( + "[...document.querySelectorAll('flt-semantics')].map(x=>{const r=x.getBoundingClientRect();return{label:(x.getAttribute('aria-label')||x.innerText||'').trim(),role:x.getAttribute('role'),x:r.x,y:r.y,w:r.width,h:r.height}})", + ); + const requireLabels = (all, needles, state) => { + for (const needle of needles) { + if (!all.some((label) => label.includes(needle))) { + throw new Error(`Missing ${JSON.stringify(needle)} in ${state}: ${JSON.stringify(all)}`); + } + } + }; + let viewport = { width: 320, height: 640 }; + const navigate = async ({ mode, host = 'material', scale = 1, theme = 'dark', width = 320, height = 640, semantics: enableSemantics = false, state } = {}) => { + viewport = { width, height }; + await send('Emulation.setEmulatedMedia', { features: [{ name: 'prefers-color-scheme', value: theme }] }, session); + const query = new URLSearchParams({ mode, host, scale: String(scale), theme }); + if (state) query.set('state', state); + await send('Page.navigate', { url: `${origin}/?${query}` }, session); + await delay(2500); + await send('Emulation.setDeviceMetricsOverride', { width, height, deviceScaleFactor: 2, mobile: true }, session); + await delay(1000); + if (enableSemantics) { + await evaluate("document.querySelector('flt-semantics-placeholder')?.click()"); + await delay(1200); + } + }; + const waitForReport = async (mode) => { + for (let attempt = 0; attempt < 80; attempt++) { + const report = await evaluate('window.__probeReport'); + if (report && report.includes(`mode=${mode}`)) return report; + await delay(150); + } + throw new Error(`The ${mode} scenario never reported`); + }; + const notifications = () => evaluate('JSON.stringify(window.__notifications)'); + const capture = async (name) => { + const data = (await send('Page.captureScreenshot', { format: 'png', captureBeyondViewport: false }, session)).data; + await writeFile(join(artifactDir, name), Buffer.from(data, 'base64')); + }; + + const grant = () => send('Browser.grantPermissions', { origin, permissions: ['notifications'] }); + const deny = () => send('Browser.setPermission', { + permission: { name: 'notifications' }, + setting: 'denied', + origin, + }); + const prompt = () => send('Browser.setPermission', { + permission: { name: 'notifications' }, + setting: 'prompt', + origin, + }); + + const checks = []; + const captures = []; + const check = (name, condition, detail) => { + if (!condition) throw new Error(`${name}: ${detail}`); + checks.push(name); + }; + + await prompt(); + + // 1. The initial list seed never notifies. + await navigate({ mode: 'seed' }); + const seedReport = await waitForReport('seed'); + check('seed report', seedReport.includes('posted=0'), seedReport); + check('seed silent', (await notifications()) === '[]', await notifications()); + + // 2. One live transition notifies exactly once, with the entry's own words. + await grant(); + await navigate({ mode: 'transition' }); + const transitionReport = await waitForReport('transition'); + check('transition posted once', transitionReport.includes('posted=1'), transitionReport); + const posted = JSON.parse(await notifications()); + check('transition count', posted.length === 1, JSON.stringify(posted)); + check('transition title', posted[0].title === 'A run failed', JSON.stringify(posted[0])); + check('transition body', posted[0].body === 'Nightly audit · nightly', JSON.stringify(posted[0])); + check('transition identity', posted[0].tag === '1:Failed', JSON.stringify(posted[0])); + await capture('notification-transition-material-dark-320-2x.png'); + captures.push('notification-transition-material-dark-320-2x.png'); + + // 3. A dismissed transition never notifies. + await navigate({ mode: 'dismissed' }); + const dismissedReport = await waitForReport('dismissed'); + check('dismissed report', dismissedReport.includes('posted=0'), dismissedReport); + check('dismissed silent', (await notifications()) === '[]', await notifications()); + + // 4. A reconnect replay never notifies again. + await navigate({ mode: 'reconnect' }); + const reconnectReport = await waitForReport('reconnect'); + check('reconnect posted once', reconnectReport.includes('posted=1'), reconnectReport); + check('reconnect count', JSON.parse(await notifications()).length === 1, await notifications()); + + // 4b. A second decision gate of one run notifies again. The waiting frames + // carry no finished_at, so the run's timestamps cannot tell the gates apart. + await navigate({ mode: 'secondgate' }); + const secondGateReport = await waitForReport('secondgate'); + check('second gate posted twice', secondGateReport.includes('posted=2'), secondGateReport); + const gates = JSON.parse(await notifications()); + check('second gate count', gates.length === 2, JSON.stringify(gates)); + check( + 'second gate identity', + gates.every((item) => item.tag === '7:Decision'), + JSON.stringify(gates), + ); + check( + 'second gate title', + gates.every((item) => item.title === 'A run needs your decision'), + JSON.stringify(gates), + ); + + // 5. A denied page is honest and posts nothing. + await deny(); + await navigate({ mode: 'denied', semantics: true }); + const deniedReport = await waitForReport('denied'); + check('denied report', deniedReport.includes('state=denied') && deniedReport.includes('posted=0'), deniedReport); + check('denied silent', (await notifications()) === '[]', await notifications()); + requireLabels(await semantics().then((rows) => rows.map((r) => r.label)), [ + 'Notifications are blocked for this site.', + ], 'denied tile'); + await capture('notification-denied-material-dark-320-2x.png'); + captures.push('notification-denied-material-dark-320-2x.png'); + + // 6. An unsupported browser is honest and posts nothing. + await grant(); + await navigate({ mode: 'unsupported', semantics: true }); + const unsupportedReport = await waitForReport('unsupported'); + check('unsupported report', unsupportedReport.includes('state=unsupported'), unsupportedReport); + check('unsupported silent', (await notifications()) === '[]', await notifications()); + requireLabels(await semantics().then((rows) => rows.map((r) => r.label)), [ + 'This browser does not support notifications.', + ], 'unsupported tile'); + await capture('notification-unsupported-material-dark-320-2x.png'); + captures.push('notification-unsupported-material-dark-320-2x.png'); + + // 7. Each tile state reads honestly on both hosts, at the hardest case: + // 320 logical px and 2x text. + await prompt(); + const states = { + unsupported: 'This browser does not support notifications.', + insecure: 'Notifications need a secure context (https or localhost).', + default: 'Notifications are off. Enable them to be told when a run fails', + granted: 'Notifications are on. Failed and waiting runs will raise a browser notification.', + denied: 'Notifications are blocked for this site.', + }; + for (const host of ['material', 'cupertino']) { + for (const [state, copy] of Object.entries(states)) { + await navigate({ mode: 'tile', host, scale: 2, semantics: true, state }); + const labels = (await semantics()).map((row) => row.label); + requireLabels(labels, [ + 'Pipelines can notify you when a run is waiting', + copy, + ], `${host} ${state} tile`); + if (state === 'default') { + requireLabels(labels, ['Enable notifications'], `${host} ${state} action`); + } + checks.push(`${host} ${state} tile`); + const name = `notification-tile-${state}-${host}-dark-320-2x.png`; + await capture(name); + captures.push(name); + } + } + + console.log(JSON.stringify({ checks, captures }, null, 2)); +} finally { + ws?.close(); + chrome.kill('SIGTERM'); + await Promise.race([once(chrome, 'exit'), delay(3000)]); + server.close(); + await rm(profile, { recursive: true, force: true }); +}