@narumitw/pi-chat 0.1.6 → 0.1.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (49) hide show
  1. package/README.md +17 -34
  2. package/dist/chunks/{chat-view-EZ24L3LM.js → chat-view-7OBZGYZM.ts} +2 -2
  3. package/dist/chunks/chat-view-7OBZGYZM.ts.map +7 -0
  4. package/dist/chunks/{chunk-ZR2JESR5.js → chunk-7FD7DDSU.ts} +6 -36
  5. package/dist/chunks/chunk-7FD7DDSU.ts.map +7 -0
  6. package/dist/chunks/{chunk-XYZZR6DW.js → chunk-EOZIFFAD.ts} +6 -23
  7. package/dist/chunks/chunk-EOZIFFAD.ts.map +7 -0
  8. package/dist/chunks/{chunk-UE3UAOJX.js → chunk-LN3NAZRC.ts} +1 -1
  9. package/dist/chunks/{chunk-UE3UAOJX.js.map → chunk-LN3NAZRC.ts.map} +1 -1
  10. package/dist/chunks/{chunk-OQLAKS7O.js → chunk-MHSYNYS3.ts} +4 -7
  11. package/dist/chunks/chunk-MHSYNYS3.ts.map +7 -0
  12. package/dist/chunks/{chunk-UQPD3L6X.js → chunk-WUCSLYAK.ts} +1 -1
  13. package/dist/chunks/chunk-WUCSLYAK.ts.map +7 -0
  14. package/dist/chunks/{directory-network-EWFZFLGK.js → directory-network-6OPGA4EH.ts} +7 -19
  15. package/dist/chunks/directory-network-6OPGA4EH.ts.map +7 -0
  16. package/dist/chunks/{menu-2KEDM6NJ.js → menu-S7MZCVYM.ts} +5 -5
  17. package/dist/chunks/menu-S7MZCVYM.ts.map +7 -0
  18. package/dist/chunks/{network-MXCIGGQ2.js → network-Y4Z4JJ5J.ts} +3 -3
  19. package/dist/chunks/network-Y4Z4JJ5J.ts.map +7 -0
  20. package/dist/chunks/{widget-4OBABJDY.js → widget-QT53EBN6.ts} +4 -10
  21. package/dist/chunks/widget-QT53EBN6.ts.map +7 -0
  22. package/dist/index.ts +20 -66
  23. package/dist/index.ts.map +2 -2
  24. package/package.json +54 -55
  25. package/src/chat-session.ts +571 -594
  26. package/src/chat-view.ts +221 -226
  27. package/src/directory-network.ts +347 -365
  28. package/src/external.d.ts +56 -66
  29. package/src/identity.ts +74 -88
  30. package/src/menu.ts +535 -541
  31. package/src/network-contract.ts +5 -5
  32. package/src/network.ts +154 -157
  33. package/src/nickname.ts +6 -6
  34. package/src/pi-chat.ts +700 -774
  35. package/src/protocol.ts +296 -335
  36. package/src/public-room-directory.ts +276 -310
  37. package/src/room.ts +54 -58
  38. package/src/settings.ts +234 -259
  39. package/src/text.ts +57 -57
  40. package/src/widget.ts +56 -72
  41. package/dist/chunks/chat-view-EZ24L3LM.js.map +0 -7
  42. package/dist/chunks/chunk-OQLAKS7O.js.map +0 -7
  43. package/dist/chunks/chunk-UQPD3L6X.js.map +0 -7
  44. package/dist/chunks/chunk-XYZZR6DW.js.map +0 -7
  45. package/dist/chunks/chunk-ZR2JESR5.js.map +0 -7
  46. package/dist/chunks/directory-network-EWFZFLGK.js.map +0 -7
  47. package/dist/chunks/menu-2KEDM6NJ.js.map +0 -7
  48. package/dist/chunks/network-MXCIGGQ2.js.map +0 -7
  49. package/dist/chunks/widget-4OBABJDY.js.map +0 -7
@@ -5,14 +5,14 @@ import type { ChatIdentity } from "./identity.js";
5
5
  import { MAX_DIRECT_NEIGHBORS } from "./network-contract.js";
6
6
  import { PeerRateLimiter } from "./protocol.js";
7
7
  import {
8
- createDirectoryPresence,
9
- createDirectoryWireMessage,
10
- DirectoryCatalog,
11
- DirectoryFrameDecoder,
12
- type DirectoryWireMessage,
13
- encodeDirectoryFrame,
14
- PUBLIC_ROOM_DIRECTORY_TOPIC,
15
- type PublicRoomBrowseResult,
8
+ createDirectoryPresence,
9
+ createDirectoryWireMessage,
10
+ DirectoryCatalog,
11
+ DirectoryFrameDecoder,
12
+ type DirectoryWireMessage,
13
+ encodeDirectoryFrame,
14
+ PUBLIC_ROOM_DIRECTORY_TOPIC,
15
+ type PublicRoomBrowseResult,
16
16
  } from "./public-room-directory.js";
17
17
 
18
18
  const DIRECTORY_HEARTBEAT_MS = 30_000;
@@ -20,397 +20,379 @@ const DIRECTORY_BROWSE_MS = 1_200;
20
20
  const MAX_SYNC_RECORDS = 256;
21
21
 
22
22
  export interface DirectoryPeer {
23
- publicKey: Buffer;
24
- send(message: DirectoryWireMessage): void;
25
- close(): void;
23
+ publicKey: Buffer;
24
+ send(message: DirectoryWireMessage): void;
25
+ close(): void;
26
26
  }
27
27
 
28
28
  export interface DirectoryTransportListener {
29
- onPeer(peer: DirectoryPeer): void;
30
- onMessage(peer: DirectoryPeer, message: DirectoryWireMessage): void;
31
- onDisconnect(peer: DirectoryPeer): void;
32
- onError(error: Error): void;
29
+ onPeer(peer: DirectoryPeer): void;
30
+ onMessage(peer: DirectoryPeer, message: DirectoryWireMessage): void;
31
+ onDisconnect(peer: DirectoryPeer): void;
32
+ onError(error: Error): void;
33
33
  }
34
34
 
35
35
  export interface DirectoryTransport {
36
- start(listener: DirectoryTransportListener, signal?: AbortSignal): Promise<void>;
37
- refresh(signal?: AbortSignal): Promise<void>;
38
- stop(): Promise<void>;
36
+ start(listener: DirectoryTransportListener, signal?: AbortSignal): Promise<void>;
37
+ refresh(signal?: AbortSignal): Promise<void>;
38
+ stop(): Promise<void>;
39
39
  }
40
40
 
41
41
  export interface PublicRoomDirectory {
42
- start(signal?: AbortSignal): Promise<void>;
43
- browse(signal: AbortSignal, collectionMs?: number): Promise<PublicRoomBrowseResult>;
44
- stop(): Promise<void>;
42
+ start(signal?: AbortSignal): Promise<void>;
43
+ browse(signal: AbortSignal, collectionMs?: number): Promise<PublicRoomBrowseResult>;
44
+ stop(): Promise<void>;
45
45
  }
46
46
 
47
47
  export interface PublicRoomDirectorySessionOptions {
48
- identity: ChatIdentity;
49
- transport: DirectoryTransport;
50
- advertisedSlug?: string;
51
- now?: () => number;
52
- createId?: () => string;
48
+ identity: ChatIdentity;
49
+ transport: DirectoryTransport;
50
+ advertisedSlug?: string;
51
+ now?: () => number;
52
+ createId?: () => string;
53
53
  }
54
54
 
55
55
  interface DirectoryPeerState {
56
- peer: DirectoryPeer;
57
- limiter: PeerRateLimiter;
58
- violations: number;
56
+ peer: DirectoryPeer;
57
+ limiter: PeerRateLimiter;
58
+ violations: number;
59
59
  }
60
60
 
61
61
  export class PublicRoomDirectorySession implements PublicRoomDirectory {
62
- private readonly identity: ChatIdentity;
63
- private readonly transport: DirectoryTransport;
64
- private readonly advertisedSlug?: string;
65
- private readonly now: () => number;
66
- private readonly createId: () => string;
67
- private readonly catalog: DirectoryCatalog;
68
- private readonly peers = new Map<string, DirectoryPeerState>();
69
- private started = false;
70
- private startPromise: Promise<void> | undefined;
71
- private stopPromise: Promise<void> | undefined;
72
- private transportStopPromise: Promise<void> | undefined;
73
- private heartbeatTimer: NodeJS.Timeout | undefined;
74
- private generation = 0;
75
-
76
- constructor(options: PublicRoomDirectorySessionOptions) {
77
- this.identity = options.identity;
78
- this.transport = options.transport;
79
- this.advertisedSlug = options.advertisedSlug;
80
- this.now = options.now ?? Date.now;
81
- this.createId = options.createId ?? randomUUID;
82
- this.catalog = new DirectoryCatalog({ now: this.now });
83
- }
84
-
85
- start(signal?: AbortSignal): Promise<void> {
86
- if (this.startPromise) return this.startPromise;
87
- if (this.stopPromise) throw new Error("Public room directory has already stopped.");
88
- this.startPromise = this.startOwned(signal);
89
- return this.startPromise;
90
- }
91
-
92
- async browse(
93
- signal: AbortSignal,
94
- collectionMs = DIRECTORY_BROWSE_MS,
95
- ): Promise<PublicRoomBrowseResult> {
96
- const temporary = !this.started && !this.advertisedSlug;
97
- try {
98
- await this.start(signal);
99
- signal.throwIfAborted();
100
- await this.transport.refresh(signal);
101
- await abortableDelay(Math.max(0, collectionMs), signal);
102
- signal.throwIfAborted();
103
- return this.catalog.snapshot();
104
- } finally {
105
- if (temporary) await this.stop();
106
- }
107
- }
108
-
109
- stop(): Promise<void> {
110
- if (this.stopPromise) return this.stopPromise;
111
- this.stopPromise = this.stopOwned();
112
- return this.stopPromise;
113
- }
114
-
115
- private async startOwned(signal?: AbortSignal): Promise<void> {
116
- const owner = ++this.generation;
117
- this.started = true;
118
- try {
119
- await this.transport.start(
120
- {
121
- onPeer: (peer) => this.onPeer(owner, peer),
122
- onMessage: (peer, message) => this.onMessage(owner, peer, message),
123
- onDisconnect: (peer) => this.onDisconnect(owner, peer),
124
- onError: () => this.catalog.markPartial(),
125
- },
126
- signal,
127
- );
128
- signal?.throwIfAborted();
129
- if (owner !== this.generation) return;
130
- if (this.advertisedSlug) this.publish("online");
131
- this.heartbeatTimer = setInterval(() => {
132
- if (owner === this.generation && this.started && this.advertisedSlug) {
133
- this.publish("online");
134
- }
135
- }, DIRECTORY_HEARTBEAT_MS);
136
- this.heartbeatTimer.unref();
137
- } catch (error) {
138
- this.started = false;
139
- await this.stopTransport();
140
- throw error;
141
- }
142
- }
143
-
144
- private onPeer(owner: number, peer: DirectoryPeer): void {
145
- if (owner !== this.generation || !this.started) {
146
- peer.close();
147
- return;
148
- }
149
- const id = peer.publicKey.toString("hex");
150
- const previous = this.peers.get(id);
151
- if (previous && previous.peer !== peer) previous.peer.close();
152
- this.peers.set(id, {
153
- peer,
154
- limiter: new PeerRateLimiter({ burst: MAX_SYNC_RECORDS, refillPerSecond: 16, now: this.now }),
155
- violations: 0,
156
- });
157
- const events = this.catalog.currentEvents();
158
- const partial = events.length > MAX_SYNC_RECORDS || this.catalog.snapshot().partial;
159
- if (events.length > MAX_SYNC_RECORDS) this.catalog.markPartial();
160
- for (const [index, event] of events.slice(0, MAX_SYNC_RECORDS).entries()) {
161
- try {
162
- peer.send(createDirectoryWireMessage(event, undefined, partial && index === 0));
163
- } catch {
164
- break;
165
- }
166
- }
167
- }
168
-
169
- private onMessage(owner: number, peer: DirectoryPeer, message: DirectoryWireMessage): void {
170
- if (owner !== this.generation || !this.started) return;
171
- const state = this.peers.get(peer.publicKey.toString("hex"));
172
- if (!state || state.peer !== peer) return;
173
- if (!state.limiter.accept()) {
174
- this.violate(state);
175
- return;
176
- }
177
- if (message.partial) this.catalog.markPartial();
178
- if (!this.catalog.accept(message.event)) {
179
- return;
180
- }
181
- if (message.hops > 1) {
182
- this.broadcast(
183
- createDirectoryWireMessage(message.event, message.hops - 1, message.partial),
184
- peer,
185
- );
186
- }
187
- }
188
-
189
- private onDisconnect(owner: number, peer: DirectoryPeer): void {
190
- if (owner !== this.generation) return;
191
- const id = peer.publicKey.toString("hex");
192
- if (this.peers.get(id)?.peer === peer) this.peers.delete(id);
193
- }
194
-
195
- private publish(status: "online" | "leaving"): void {
196
- if (!this.advertisedSlug) return;
197
- const event = createDirectoryPresence(
198
- this.identity,
199
- this.advertisedSlug,
200
- status,
201
- this.now(),
202
- this.createId(),
203
- );
204
- this.catalog.accept(event);
205
- this.broadcast(createDirectoryWireMessage(event));
206
- }
207
-
208
- private broadcast(message: DirectoryWireMessage, exclude?: DirectoryPeer): void {
209
- for (const state of this.peers.values()) {
210
- if (state.peer === exclude) continue;
211
- try {
212
- state.peer.send(message);
213
- } catch {
214
- state.violations += 1;
215
- }
216
- }
217
- }
218
-
219
- private violate(state: DirectoryPeerState): void {
220
- state.violations += 1;
221
- if (state.violations > 3) {
222
- state.peer.close();
223
- this.peers.delete(state.peer.publicKey.toString("hex"));
224
- }
225
- }
226
-
227
- private async stopOwned(): Promise<void> {
228
- this.generation += 1;
229
- if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
230
- this.heartbeatTimer = undefined;
231
- if (this.started && this.advertisedSlug) this.publish("leaving");
232
- this.started = false;
233
- for (const state of this.peers.values()) state.peer.close();
234
- this.peers.clear();
235
- await this.stopTransport();
236
- }
237
-
238
- private stopTransport(): Promise<void> {
239
- if (!this.transportStopPromise) {
240
- this.transportStopPromise = this.transport.stop().catch(() => undefined);
241
- }
242
- return this.transportStopPromise;
243
- }
62
+ private readonly identity: ChatIdentity;
63
+ private readonly transport: DirectoryTransport;
64
+ private readonly advertisedSlug?: string;
65
+ private readonly now: () => number;
66
+ private readonly createId: () => string;
67
+ private readonly catalog: DirectoryCatalog;
68
+ private readonly peers = new Map<string, DirectoryPeerState>();
69
+ private started = false;
70
+ private startPromise: Promise<void> | undefined;
71
+ private stopPromise: Promise<void> | undefined;
72
+ private transportStopPromise: Promise<void> | undefined;
73
+ private heartbeatTimer: NodeJS.Timeout | undefined;
74
+ private generation = 0;
75
+
76
+ constructor(options: PublicRoomDirectorySessionOptions) {
77
+ this.identity = options.identity;
78
+ this.transport = options.transport;
79
+ this.advertisedSlug = options.advertisedSlug;
80
+ this.now = options.now ?? Date.now;
81
+ this.createId = options.createId ?? randomUUID;
82
+ this.catalog = new DirectoryCatalog({ now: this.now });
83
+ }
84
+
85
+ start(signal?: AbortSignal): Promise<void> {
86
+ if (this.startPromise) return this.startPromise;
87
+ if (this.stopPromise) throw new Error("Public room directory has already stopped.");
88
+ this.startPromise = this.startOwned(signal);
89
+ return this.startPromise;
90
+ }
91
+
92
+ async browse(signal: AbortSignal, collectionMs = DIRECTORY_BROWSE_MS): Promise<PublicRoomBrowseResult> {
93
+ const temporary = !this.started && !this.advertisedSlug;
94
+ try {
95
+ await this.start(signal);
96
+ signal.throwIfAborted();
97
+ await this.transport.refresh(signal);
98
+ await abortableDelay(Math.max(0, collectionMs), signal);
99
+ signal.throwIfAborted();
100
+ return this.catalog.snapshot();
101
+ } finally {
102
+ if (temporary) await this.stop();
103
+ }
104
+ }
105
+
106
+ stop(): Promise<void> {
107
+ if (this.stopPromise) return this.stopPromise;
108
+ this.stopPromise = this.stopOwned();
109
+ return this.stopPromise;
110
+ }
111
+
112
+ private async startOwned(signal?: AbortSignal): Promise<void> {
113
+ const owner = ++this.generation;
114
+ this.started = true;
115
+ try {
116
+ await this.transport.start(
117
+ {
118
+ onPeer: (peer) => this.onPeer(owner, peer),
119
+ onMessage: (peer, message) => this.onMessage(owner, peer, message),
120
+ onDisconnect: (peer) => this.onDisconnect(owner, peer),
121
+ onError: () => this.catalog.markPartial(),
122
+ },
123
+ signal,
124
+ );
125
+ signal?.throwIfAborted();
126
+ if (owner !== this.generation) return;
127
+ if (this.advertisedSlug) this.publish("online");
128
+ this.heartbeatTimer = setInterval(() => {
129
+ if (owner === this.generation && this.started && this.advertisedSlug) {
130
+ this.publish("online");
131
+ }
132
+ }, DIRECTORY_HEARTBEAT_MS);
133
+ this.heartbeatTimer.unref();
134
+ } catch (error) {
135
+ this.started = false;
136
+ await this.stopTransport();
137
+ throw error;
138
+ }
139
+ }
140
+
141
+ private onPeer(owner: number, peer: DirectoryPeer): void {
142
+ if (owner !== this.generation || !this.started) {
143
+ peer.close();
144
+ return;
145
+ }
146
+ const id = peer.publicKey.toString("hex");
147
+ const previous = this.peers.get(id);
148
+ if (previous && previous.peer !== peer) previous.peer.close();
149
+ this.peers.set(id, {
150
+ peer,
151
+ limiter: new PeerRateLimiter({ burst: MAX_SYNC_RECORDS, refillPerSecond: 16, now: this.now }),
152
+ violations: 0,
153
+ });
154
+ const events = this.catalog.currentEvents();
155
+ const partial = events.length > MAX_SYNC_RECORDS || this.catalog.snapshot().partial;
156
+ if (events.length > MAX_SYNC_RECORDS) this.catalog.markPartial();
157
+ for (const [index, event] of events.slice(0, MAX_SYNC_RECORDS).entries()) {
158
+ try {
159
+ peer.send(createDirectoryWireMessage(event, undefined, partial && index === 0));
160
+ } catch {
161
+ break;
162
+ }
163
+ }
164
+ }
165
+
166
+ private onMessage(owner: number, peer: DirectoryPeer, message: DirectoryWireMessage): void {
167
+ if (owner !== this.generation || !this.started) return;
168
+ const state = this.peers.get(peer.publicKey.toString("hex"));
169
+ if (!state || state.peer !== peer) return;
170
+ if (!state.limiter.accept()) {
171
+ this.violate(state);
172
+ return;
173
+ }
174
+ if (message.partial) this.catalog.markPartial();
175
+ if (!this.catalog.accept(message.event)) {
176
+ return;
177
+ }
178
+ if (message.hops > 1) {
179
+ this.broadcast(createDirectoryWireMessage(message.event, message.hops - 1, message.partial), peer);
180
+ }
181
+ }
182
+
183
+ private onDisconnect(owner: number, peer: DirectoryPeer): void {
184
+ if (owner !== this.generation) return;
185
+ const id = peer.publicKey.toString("hex");
186
+ if (this.peers.get(id)?.peer === peer) this.peers.delete(id);
187
+ }
188
+
189
+ private publish(status: "online" | "leaving"): void {
190
+ if (!this.advertisedSlug) return;
191
+ const event = createDirectoryPresence(this.identity, this.advertisedSlug, status, this.now(), this.createId());
192
+ this.catalog.accept(event);
193
+ this.broadcast(createDirectoryWireMessage(event));
194
+ }
195
+
196
+ private broadcast(message: DirectoryWireMessage, exclude?: DirectoryPeer): void {
197
+ for (const state of this.peers.values()) {
198
+ if (state.peer === exclude) continue;
199
+ try {
200
+ state.peer.send(message);
201
+ } catch {
202
+ state.violations += 1;
203
+ }
204
+ }
205
+ }
206
+
207
+ private violate(state: DirectoryPeerState): void {
208
+ state.violations += 1;
209
+ if (state.violations > 3) {
210
+ state.peer.close();
211
+ this.peers.delete(state.peer.publicKey.toString("hex"));
212
+ }
213
+ }
214
+
215
+ private async stopOwned(): Promise<void> {
216
+ this.generation += 1;
217
+ if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
218
+ this.heartbeatTimer = undefined;
219
+ if (this.started && this.advertisedSlug) this.publish("leaving");
220
+ this.started = false;
221
+ for (const state of this.peers.values()) state.peer.close();
222
+ this.peers.clear();
223
+ await this.stopTransport();
224
+ }
225
+
226
+ private stopTransport(): Promise<void> {
227
+ if (!this.transportStopPromise) {
228
+ this.transportStopPromise = this.transport.stop().catch(() => undefined);
229
+ }
230
+ return this.transportStopPromise;
231
+ }
244
232
  }
245
233
 
246
234
  export interface HyperswarmDirectoryTransportOptions {
247
- identity: ChatIdentity;
248
- dht?: unknown;
249
- bootstrap?: unknown[];
235
+ identity: ChatIdentity;
236
+ dht?: unknown;
237
+ bootstrap?: unknown[];
250
238
  }
251
239
 
252
240
  interface ActiveConnection {
253
- socket: Duplex;
254
- peer: DirectoryPeer;
241
+ socket: Duplex;
242
+ peer: DirectoryPeer;
255
243
  }
256
244
 
257
245
  export class HyperswarmDirectoryTransport implements DirectoryTransport {
258
- private readonly options: HyperswarmDirectoryTransportOptions;
259
- private swarm: Hyperswarm | undefined;
260
- private discovery: PeerDiscovery | undefined;
261
- private listener: DirectoryTransportListener | undefined;
262
- private readonly connections = new Map<Duplex, ActiveConnection>();
263
- private stopPromise: Promise<void> | undefined;
264
-
265
- constructor(options: HyperswarmDirectoryTransportOptions) {
266
- this.options = options;
267
- }
268
-
269
- async start(listener: DirectoryTransportListener, signal?: AbortSignal): Promise<void> {
270
- if (this.swarm) throw new Error("Public room directory transport has already started.");
271
- const startupSignal = signal
272
- ? AbortSignal.any([signal, AbortSignal.timeout(15_000)])
273
- : AbortSignal.timeout(15_000);
274
- startupSignal.throwIfAborted();
275
- this.listener = listener;
276
- const swarm = new Hyperswarm({
277
- keyPair: {
278
- publicKey: this.options.identity.publicKey,
279
- secretKey: this.options.identity.secretKey,
280
- },
281
- maxPeers: MAX_DIRECT_NEIGHBORS,
282
- ...(this.options.dht ? { dht: this.options.dht } : {}),
283
- ...(this.options.bootstrap ? { bootstrap: this.options.bootstrap } : {}),
284
- });
285
- this.swarm = swarm;
286
- swarm.on("connection", (socket, info) => this.accept(socket, info));
287
- swarm.on("error", (error) => this.listener?.onError(safeNetworkError(error)));
288
- try {
289
- this.discovery = swarm.join(PUBLIC_ROOM_DIRECTORY_TOPIC, {
290
- server: true,
291
- client: true,
292
- limit: MAX_DIRECT_NEIGHBORS,
293
- });
294
- await raceAbort(this.discovery.flushed(), startupSignal);
295
- startupSignal.throwIfAborted();
296
- } catch (error) {
297
- await this.stop();
298
- throw error;
299
- }
300
- }
301
-
302
- async refresh(signal?: AbortSignal): Promise<void> {
303
- if (!this.discovery) throw new Error("Public room directory is not running.");
304
- await raceAbort(
305
- this.discovery.refresh({ server: true, client: true, limit: MAX_DIRECT_NEIGHBORS }),
306
- signal,
307
- );
308
- }
309
-
310
- stop(): Promise<void> {
311
- if (this.stopPromise) return this.stopPromise;
312
- this.stopPromise = this.stopOwned();
313
- return this.stopPromise;
314
- }
315
-
316
- private accept(socket: Duplex, info: PeerInfo): void {
317
- if (!this.swarm || !this.listener || this.connections.size >= MAX_DIRECT_NEIGHBORS) {
318
- socket.destroy();
319
- return;
320
- }
321
- const decoder = new DirectoryFrameDecoder();
322
- let closed = false;
323
- const peer: DirectoryPeer = {
324
- publicKey: Buffer.from(info.publicKey),
325
- send(message) {
326
- if (closed || socket.destroyed) throw new Error("Directory peer connection is closed.");
327
- const accepted = socket.write(encodeDirectoryFrame(message));
328
- if (!accepted && socket.destroyed) {
329
- throw new Error("Directory peer connection rejected the message.");
330
- }
331
- },
332
- close() {
333
- if (closed) return;
334
- closed = true;
335
- socket.destroy();
336
- },
337
- };
338
- this.connections.set(socket, { socket, peer });
339
- this.listener.onPeer(peer);
340
- socket.on("data", (chunk: unknown) => {
341
- if (closed || !this.listener) return;
342
- try {
343
- const bytes =
344
- typeof chunk === "string"
345
- ? Buffer.from(chunk)
346
- : Buffer.isBuffer(chunk)
347
- ? chunk
348
- : Buffer.from(chunk as Uint8Array);
349
- for (const message of decoder.push(bytes)) this.listener.onMessage(peer, message);
350
- } catch {
351
- closed = true;
352
- socket.destroy();
353
- this.listener?.onError(new Error("Pi Chat rejected invalid directory protocol data."));
354
- }
355
- });
356
- const disconnected = () => {
357
- if (!this.connections.delete(socket)) return;
358
- closed = true;
359
- this.listener?.onDisconnect(peer);
360
- };
361
- socket.once("close", disconnected);
362
- socket.once("error", (error) => {
363
- this.listener?.onError(safeNetworkError(error));
364
- disconnected();
365
- });
366
- }
367
-
368
- private async stopOwned(): Promise<void> {
369
- const discovery = this.discovery;
370
- this.discovery = undefined;
371
- if (discovery) await discovery.destroy().catch(() => undefined);
372
- for (const { socket } of this.connections.values()) socket.destroy();
373
- this.connections.clear();
374
- const swarm = this.swarm;
375
- this.swarm = undefined;
376
- this.listener = undefined;
377
- if (swarm) await swarm.destroy().catch(() => undefined);
378
- }
246
+ private readonly options: HyperswarmDirectoryTransportOptions;
247
+ private swarm: Hyperswarm | undefined;
248
+ private discovery: PeerDiscovery | undefined;
249
+ private listener: DirectoryTransportListener | undefined;
250
+ private readonly connections = new Map<Duplex, ActiveConnection>();
251
+ private stopPromise: Promise<void> | undefined;
252
+
253
+ constructor(options: HyperswarmDirectoryTransportOptions) {
254
+ this.options = options;
255
+ }
256
+
257
+ async start(listener: DirectoryTransportListener, signal?: AbortSignal): Promise<void> {
258
+ if (this.swarm) throw new Error("Public room directory transport has already started.");
259
+ const startupSignal = signal ? AbortSignal.any([signal, AbortSignal.timeout(15_000)]) : AbortSignal.timeout(15_000);
260
+ startupSignal.throwIfAborted();
261
+ this.listener = listener;
262
+ const swarm = new Hyperswarm({
263
+ keyPair: {
264
+ publicKey: this.options.identity.publicKey,
265
+ secretKey: this.options.identity.secretKey,
266
+ },
267
+ maxPeers: MAX_DIRECT_NEIGHBORS,
268
+ ...(this.options.dht ? { dht: this.options.dht } : {}),
269
+ ...(this.options.bootstrap ? { bootstrap: this.options.bootstrap } : {}),
270
+ });
271
+ this.swarm = swarm;
272
+ swarm.on("connection", (socket, info) => this.accept(socket, info));
273
+ swarm.on("error", (error) => this.listener?.onError(safeNetworkError(error)));
274
+ try {
275
+ this.discovery = swarm.join(PUBLIC_ROOM_DIRECTORY_TOPIC, {
276
+ server: true,
277
+ client: true,
278
+ limit: MAX_DIRECT_NEIGHBORS,
279
+ });
280
+ await raceAbort(this.discovery.flushed(), startupSignal);
281
+ startupSignal.throwIfAborted();
282
+ } catch (error) {
283
+ await this.stop();
284
+ throw error;
285
+ }
286
+ }
287
+
288
+ async refresh(signal?: AbortSignal): Promise<void> {
289
+ if (!this.discovery) throw new Error("Public room directory is not running.");
290
+ await raceAbort(this.discovery.refresh({ server: true, client: true, limit: MAX_DIRECT_NEIGHBORS }), signal);
291
+ }
292
+
293
+ stop(): Promise<void> {
294
+ if (this.stopPromise) return this.stopPromise;
295
+ this.stopPromise = this.stopOwned();
296
+ return this.stopPromise;
297
+ }
298
+
299
+ private accept(socket: Duplex, info: PeerInfo): void {
300
+ if (!this.swarm || !this.listener || this.connections.size >= MAX_DIRECT_NEIGHBORS) {
301
+ socket.destroy();
302
+ return;
303
+ }
304
+ const decoder = new DirectoryFrameDecoder();
305
+ let closed = false;
306
+ const peer: DirectoryPeer = {
307
+ publicKey: Buffer.from(info.publicKey),
308
+ send(message) {
309
+ if (closed || socket.destroyed) throw new Error("Directory peer connection is closed.");
310
+ const accepted = socket.write(encodeDirectoryFrame(message));
311
+ if (!accepted && socket.destroyed) {
312
+ throw new Error("Directory peer connection rejected the message.");
313
+ }
314
+ },
315
+ close() {
316
+ if (closed) return;
317
+ closed = true;
318
+ socket.destroy();
319
+ },
320
+ };
321
+ this.connections.set(socket, { socket, peer });
322
+ this.listener.onPeer(peer);
323
+ socket.on("data", (chunk: unknown) => {
324
+ if (closed || !this.listener) return;
325
+ try {
326
+ const bytes =
327
+ typeof chunk === "string"
328
+ ? Buffer.from(chunk)
329
+ : Buffer.isBuffer(chunk)
330
+ ? chunk
331
+ : Buffer.from(chunk as Uint8Array);
332
+ for (const message of decoder.push(bytes)) this.listener.onMessage(peer, message);
333
+ } catch {
334
+ closed = true;
335
+ socket.destroy();
336
+ this.listener?.onError(new Error("Pi Chat rejected invalid directory protocol data."));
337
+ }
338
+ });
339
+ const disconnected = () => {
340
+ if (!this.connections.delete(socket)) return;
341
+ closed = true;
342
+ this.listener?.onDisconnect(peer);
343
+ };
344
+ socket.once("close", disconnected);
345
+ socket.once("error", (error) => {
346
+ this.listener?.onError(safeNetworkError(error));
347
+ disconnected();
348
+ });
349
+ }
350
+
351
+ private async stopOwned(): Promise<void> {
352
+ const discovery = this.discovery;
353
+ this.discovery = undefined;
354
+ if (discovery) await discovery.destroy().catch(() => undefined);
355
+ for (const { socket } of this.connections.values()) socket.destroy();
356
+ this.connections.clear();
357
+ const swarm = this.swarm;
358
+ this.swarm = undefined;
359
+ this.listener = undefined;
360
+ if (swarm) await swarm.destroy().catch(() => undefined);
361
+ }
379
362
  }
380
363
 
381
364
  async function abortableDelay(milliseconds: number, signal: AbortSignal): Promise<void> {
382
- signal.throwIfAborted();
383
- await new Promise<void>((resolve, reject) => {
384
- const timer = setTimeout(done, milliseconds);
385
- const abort = () => done(signal.reason ?? new DOMException("Aborted", "AbortError"));
386
- function done(error?: unknown): void {
387
- clearTimeout(timer);
388
- signal.removeEventListener("abort", abort);
389
- if (error) reject(error);
390
- else resolve();
391
- }
392
- signal.addEventListener("abort", abort, { once: true });
393
- });
365
+ signal.throwIfAborted();
366
+ await new Promise<void>((resolve, reject) => {
367
+ const timer = setTimeout(done, milliseconds);
368
+ const abort = () => done(signal.reason ?? new DOMException("Aborted", "AbortError"));
369
+ function done(error?: unknown): void {
370
+ clearTimeout(timer);
371
+ signal.removeEventListener("abort", abort);
372
+ if (error) reject(error);
373
+ else resolve();
374
+ }
375
+ signal.addEventListener("abort", abort, { once: true });
376
+ });
394
377
  }
395
378
 
396
379
  async function raceAbort<T>(operation: Promise<T>, signal?: AbortSignal): Promise<T> {
397
- if (!signal) return operation;
398
- signal.throwIfAborted();
399
- let remove = () => {};
400
- const aborted = new Promise<never>((_resolve, reject) => {
401
- const onAbort = () => reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
402
- signal.addEventListener("abort", onAbort, { once: true });
403
- remove = () => signal.removeEventListener("abort", onAbort);
404
- });
405
- try {
406
- return await Promise.race([operation, aborted]);
407
- } finally {
408
- remove();
409
- }
380
+ if (!signal) return operation;
381
+ signal.throwIfAborted();
382
+ let remove = () => {};
383
+ const aborted = new Promise<never>((_resolve, reject) => {
384
+ const onAbort = () => reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
385
+ signal.addEventListener("abort", onAbort, { once: true });
386
+ remove = () => signal.removeEventListener("abort", onAbort);
387
+ });
388
+ try {
389
+ return await Promise.race([operation, aborted]);
390
+ } finally {
391
+ remove();
392
+ }
410
393
  }
411
394
 
412
395
  function safeNetworkError(error: unknown): Error {
413
- const code =
414
- error instanceof Error && "code" in error ? String(Reflect.get(error, "code")) : "error";
415
- return new Error(`Pi Chat directory network ${code}.`);
396
+ const code = error instanceof Error && "code" in error ? String(Reflect.get(error, "code")) : "error";
397
+ return new Error(`Pi Chat directory network ${code}.`);
416
398
  }