Skip to content

Commit f3f7078

Browse files
author
Tryn McCaffery
committed
fix(mobile): deliver DMs after reconnect
Signed-off-by: Tryn McCaffery <[email protected]>
1 parent f25e6dd commit f3f7078

4 files changed

Lines changed: 153 additions & 11 deletions

File tree

‎mobile/lib/features/channels/send_message_provider.dart‎

Lines changed: 22 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,18 @@
11
import 'package:hooks_riverpod/hooks_riverpod.dart';
22

33
import '../../shared/relay/relay.dart';
4-
import '../channels/channel_management_provider.dart';
54
import '../profile/user_cache_provider.dart';
65
import '../profile/user_profile.dart';
6+
import 'channel_management_provider.dart';
77
import 'channel_messages_provider.dart';
8+
import 'channels_provider.dart';
89

910
/// Sends messages by signing an event with the user's nsec and publishing it
1011
/// over the relay's NIP-42-authenticated WebSocket session.
1112
class SendMessage {
1213
final SignedEventRelay _signedEventRelay;
1314
final Future<List<ChannelMember>> Function(String channelId) _fetchMembers;
15+
final bool Function(String channelId) _isDmChannel;
1416
final Map<String, UserProfile> Function() _readUserCache;
1517
final void Function(String channelId, NostrEvent event) _addLocalMessage;
1618
final void Function(String channelId, String eventId) _completeLocalMessage;
@@ -20,13 +22,15 @@ class SendMessage {
2022
required SignedEventRelay signedEventRelay,
2123
required Future<List<ChannelMember>> Function(String channelId)
2224
fetchMembers,
25+
required bool Function(String channelId) isDmChannel,
2326
required Map<String, UserProfile> Function() readUserCache,
2427
required void Function(String channelId, NostrEvent event) addLocalMessage,
2528
required void Function(String channelId, String eventId)
2629
completeLocalMessage,
2730
required void Function(String channelId, String eventId) removeLocalMessage,
2831
}) : _signedEventRelay = signedEventRelay,
2932
_fetchMembers = fetchMembers,
33+
_isDmChannel = isDmChannel,
3034
_readUserCache = readUserCache,
3135
_addLocalMessage = addLocalMessage,
3236
_completeLocalMessage = completeLocalMessage,
@@ -53,12 +57,22 @@ class SendMessage {
5357
mentionPubkeys ?? await _resolveMentions(content, channelId);
5458
final authorPubkey = _signedEventRelay.pubkey;
5559

60+
// DM messages address every participant. Agent runtimes use these p-tags
61+
// both to wake the addressed agent and to distinguish an intentional DM
62+
// from an unaddressed channel event. Desktop already follows this
63+
// contract; mobile must do the same.
64+
final addressedPubkeys = <String>[...resolvedMentions];
65+
if (_isDmChannel(channelId)) {
66+
final members = await _fetchMembers(channelId);
67+
addressedPubkeys.addAll(members.map((member) => member.pubkey));
68+
}
69+
5670
// Normalize mentions: lowercase, deduplicate, exclude self (matching
5771
// the desktop's normalizeMentionPubkeys).
5872
final selfLower = authorPubkey?.toLowerCase();
5973
final seenMentions = <String>{?selfLower};
6074
final normalizedMentions = <String>[
61-
for (final pk in resolvedMentions)
75+
for (final pk in addressedPubkeys)
6276
if (seenMentions.add(pk.toLowerCase())) pk,
6377
];
6478

@@ -169,6 +183,12 @@ final sendMessageProvider = Provider<SendMessage>((ref) {
169183
),
170184
fetchMembers: (channelId) =>
171185
ref.read(channelMembersProvider(channelId).future),
186+
isDmChannel: (channelId) =>
187+
ref
188+
.read(channelsProvider)
189+
.value
190+
?.any((channel) => channel.id == channelId && channel.isDm) ??
191+
false,
172192
readUserCache: () => ref.read(userCacheProvider),
173193
addLocalMessage: (channelId, event) => ref
174194
.read(channelMessagesProvider(channelId).notifier)

‎mobile/lib/features/profile/presence_cache_provider.dart‎

Lines changed: 50 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -12,8 +12,11 @@ import '../../shared/relay/relay.dart';
1212
/// publish presence purely over WS are fine, and TTL expiry will be handled
1313
/// by the relay-side `presence:true` filter extension when that lands.
1414
class PresenceCacheNotifier extends Notifier<Map<String, String>> {
15+
static const _backstopInterval = Duration(seconds: 60);
16+
1517
final Set<String> _tracked = {};
1618
void Function()? _presenceUnsub;
19+
Timer? _backstopTimer;
1720
int _subscriptionVersion = 0;
1821

1922
@override
@@ -23,26 +26,59 @@ class PresenceCacheNotifier extends Notifier<Map<String, String>> {
2326
ref.onDispose(() {
2427
_presenceUnsub?.call();
2528
_presenceUnsub = null;
29+
_backstopTimer?.cancel();
30+
_backstopTimer = null;
2631
});
2732

2833
if (sessionState.status == SessionStatus.connected) {
2934
_subscribePresenceUpdates();
35+
_refreshTrackedPresence();
36+
_backstopTimer?.cancel();
37+
_backstopTimer = Timer.periodic(
38+
_backstopInterval,
39+
(_) => _refreshTrackedPresence(),
40+
);
3041
}
3142

3243
return {};
3344
}
3445

3546
/// Track presence for [pubkeys].
3647
///
37-
/// Currently a no-op for the actual fetch — we rely on live kind:20001
38-
/// events. The tracked set is still used to filter incoming events so the
39-
/// cache doesn't grow unbounded.
4048
void track(List<String> pubkeys) {
4149
final normalized = pubkeys.map((pk) => pk.toLowerCase()).toList();
42-
_tracked.addAll(normalized);
43-
// TODO(presence): once the relay supports a `presence:true` filter
44-
// extension, issue a one-shot fetch here for the latest known state per
45-
// pubkey. Until then, presence is "online whenever they publish".
50+
var changed = false;
51+
for (final pubkey in normalized) {
52+
changed = _tracked.add(pubkey) || changed;
53+
}
54+
if (changed &&
55+
ref.read(relaySessionProvider).status == SessionStatus.connected) {
56+
_refreshTrackedPresence();
57+
}
58+
}
59+
60+
/// Hydrate the cache from the relay's Redis-backed presence snapshot.
61+
///
62+
/// Presence events are ephemeral, so a client that opens after an agent's
63+
/// heartbeat cannot rely on the live subscription alone.
64+
Future<void> _refreshTrackedPresence() async {
65+
if (_tracked.isEmpty) return;
66+
try {
67+
final events = await ref
68+
.read(relaySessionProvider.notifier)
69+
.queryRelay([
70+
NostrFilter(
71+
kinds: const [EventKind.presenceUpdate],
72+
authors: _tracked.toList(),
73+
limit: _tracked.length,
74+
),
75+
]);
76+
for (final event in events) {
77+
_handlePresenceEvent(event);
78+
}
79+
} catch (error) {
80+
debugPrint('[PresenceCacheNotifier] presence refresh failed: $error');
81+
}
4682
}
4783

4884
/// Subscribe to kind:20001 presence events over WebSocket.
@@ -73,7 +109,13 @@ class PresenceCacheNotifier extends Notifier<Map<String, String>> {
73109
}
74110

75111
void _handlePresenceEvent(NostrEvent event) {
76-
final pubkey = event.pubkey.toLowerCase();
112+
// Relay-synthesized snapshots are relay-signed and identify the actual
113+
// subject with a p-tag. Live events are self-signed by their subject.
114+
final taggedSubject = event.tags
115+
.where((tag) => tag.length >= 2 && tag[0] == 'p')
116+
.map((tag) => tag[1])
117+
.firstOrNull;
118+
final pubkey = (taggedSubject ?? event.pubkey).toLowerCase();
77119
if (!_tracked.contains(pubkey)) return;
78120
final status = event.content;
79121
if (status != 'online' && status != 'away' && status != 'offline') return;

‎mobile/lib/shared/relay/relay_session.dart‎

Lines changed: 28 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -249,7 +249,9 @@ class RelaySessionNotifier extends Notifier<SessionState> {
249249
Future<NostrEvent> publish(
250250
NostrEvent event, {
251251
Duration timeout = const Duration(seconds: 8),
252-
}) {
252+
}) async {
253+
await _waitUntilConnected(timeout);
254+
253255
final completer = Completer<NostrEvent>();
254256

255257
final timer = Timer(timeout, () {
@@ -272,6 +274,31 @@ class RelaySessionNotifier extends Notifier<SessionState> {
272274
return completer.future;
273275
}
274276

277+
Future<void> _waitUntilConnected(Duration timeout) async {
278+
if (state.status == SessionStatus.connected) return;
279+
if (_paused) {
280+
throw StateError('Cannot publish while the app is in the background');
281+
}
282+
283+
if (state.status == SessionStatus.disconnected) {
284+
final config = ref.read(relayConfigProvider);
285+
unawaited(_connect(config));
286+
}
287+
288+
final deadline = DateTime.now().add(timeout);
289+
while (state.status != SessionStatus.connected) {
290+
if (_disposed || _paused) {
291+
throw StateError('Relay connection unavailable');
292+
}
293+
if (DateTime.now().isAfter(deadline)) {
294+
throw TimeoutException(
295+
'Relay did not reconnect within $timeout',
296+
);
297+
}
298+
await Future<void>.delayed(const Duration(milliseconds: 50));
299+
}
300+
}
301+
275302
/// Send a raw message over the WebSocket without waiting for acknowledgement.
276303
/// Used for ephemeral events like typing indicators.
277304
void sendRaw(List<dynamic> payload) {

‎mobile/test/features/channels/send_message_provider_test.dart‎

Lines changed: 53 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@ import 'dart:async';
22

33
import 'package:flutter_test/flutter_test.dart';
44
import 'package:nostr/nostr.dart' as nostr;
5+
import 'package:buzz/features/channels/channel_management_provider.dart';
56
import 'package:buzz/features/channels/send_message_provider.dart';
67
import 'package:buzz/shared/relay/relay.dart';
78

@@ -19,6 +20,7 @@ void main() {
1920
nsec: nostr.Keys.generate().nsec,
2021
),
2122
fetchMembers: (_) async => const [],
23+
isDmChannel: (_) => false,
2224
readUserCache: () => const {},
2325
addLocalMessage: (_, event) => localMessages.add(event),
2426
completeLocalMessage: (_, eventId) => completedIds.add(eventId),
@@ -52,6 +54,7 @@ void main() {
5254
nsec: nostr.Keys.generate().nsec,
5355
),
5456
fetchMembers: (_) async => const [],
57+
isDmChannel: (_) => false,
5558
readUserCache: () => const {},
5659
addLocalMessage: (_, event) => localMessages.add(event),
5760
completeLocalMessage: (_, eventId) => completedIds.add(eventId),
@@ -66,6 +69,56 @@ void main() {
6669
expect(completedIds, isEmpty);
6770
expect(removedIds, [localMessages.single.id]);
6871
});
72+
73+
test(
74+
'addresses every DM participant so agent subscribers receive it',
75+
() async {
76+
final session = _PendingPublishRelaySession();
77+
final signer = nostr.Keys.generate();
78+
final agent = nostr.Keys.generate();
79+
final other = nostr.Keys.generate();
80+
final send = SendMessage(
81+
signedEventRelay: SignedEventRelay(
82+
session: session,
83+
nsec: signer.nsec,
84+
),
85+
fetchMembers: (_) async => [
86+
ChannelMember(
87+
pubkey: signer.public,
88+
role: 'member',
89+
joinedAt: DateTime.fromMillisecondsSinceEpoch(0),
90+
),
91+
ChannelMember(
92+
pubkey: agent.public,
93+
role: 'bot',
94+
joinedAt: DateTime.fromMillisecondsSinceEpoch(0),
95+
),
96+
ChannelMember(
97+
pubkey: other.public,
98+
role: 'member',
99+
joinedAt: DateTime.fromMillisecondsSinceEpoch(0),
100+
),
101+
],
102+
isDmChannel: (_) => true,
103+
readUserCache: () => const {},
104+
addLocalMessage: (_, _) {},
105+
completeLocalMessage: (_, _) {},
106+
removeLocalMessage: (_, _) {},
107+
);
108+
109+
final result = send(channelId: _channelId, content: 'hello');
110+
await session.published;
111+
112+
expect(session.event.tags, containsAll([
113+
['p', agent.public],
114+
['p', other.public],
115+
]));
116+
expect(session.event.tags, isNot(contains(['p', signer.public])));
117+
118+
session.accept();
119+
await result;
120+
},
121+
);
69122
}
70123

71124
const _channelId = '11111111-1111-4111-8111-111111111111';

0 commit comments

Comments
 (0)