@narumitw/pi-chat 0.1.2 → 0.1.3

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.
package/dist/index.ts ADDED
@@ -0,0 +1,1222 @@
1
+ // @generated by scripts/build-runtime.mjs; do not edit.
2
+ // @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
3
+ import {
4
+ MAX_DIRECT_NEIGHBORS
5
+ } from "./chunks/chunk-RCEMXXHH.js";
6
+ import {
7
+ awaitChatSettingsWrites,
8
+ chatSettingsPath,
9
+ descriptorFromRememberedRoom,
10
+ readChatSettings,
11
+ rememberedRoomFromDescriptor,
12
+ updateChatSettings
13
+ } from "./chunks/chunk-2N4YIKBV.js";
14
+ import {
15
+ MAX_EVENT_AGE_MS,
16
+ PeerRateLimiter,
17
+ createChatEvent,
18
+ createGossipMessage,
19
+ createHello,
20
+ createIdentity,
21
+ createPresenceEvent,
22
+ createPrivateRoom,
23
+ createPublicRoom,
24
+ deriveScopedIdentity,
25
+ formatIdentityLabel,
26
+ normalizeNickname,
27
+ parseInvite,
28
+ uniqueIdentityTags,
29
+ verifyHello,
30
+ verifyRoomEvent
31
+ } from "./chunks/chunk-4O25EPNQ.js";
32
+ import {
33
+ sanitizeSingleLine
34
+ } from "./chunks/chunk-IVUX27XD.js";
35
+
36
+ // src/pi-chat.ts
37
+ import { randomBytes as nodeRandomBytes } from "node:crypto";
38
+
39
+ // src/chat-session.ts
40
+ import { randomBytes, randomUUID } from "node:crypto";
41
+ var MAX_TRANSCRIPT = 256;
42
+ var MAX_SEEN_MESSAGES = 8192;
43
+ var SEEN_MESSAGE_TTL_MS = 10 * 6e4;
44
+ var MAX_PROTOCOL_VIOLATIONS = 3;
45
+ var MAX_PARTICIPANTS = 256;
46
+ var PARTICIPANT_TTL_MS = 9e4;
47
+ var PRESENCE_HEARTBEAT_MS = 3e4;
48
+ var MAX_ORIGIN_LIMITERS = 512;
49
+ var ChatSession = class {
50
+ room;
51
+ identity;
52
+ nickname;
53
+ transport;
54
+ now;
55
+ onChange;
56
+ peers = /* @__PURE__ */ new Map();
57
+ participants = /* @__PURE__ */ new Map();
58
+ mutedOrigins = /* @__PURE__ */ new Set();
59
+ transcript = [];
60
+ seen = /* @__PURE__ */ new Map();
61
+ seenOrder = [];
62
+ originLimiters = /* @__PURE__ */ new Map();
63
+ participantVersions = /* @__PURE__ */ new Map();
64
+ listeners = /* @__PURE__ */ new Set();
65
+ state = "disconnected";
66
+ unread = 0;
67
+ viewOpen = false;
68
+ lastError;
69
+ generation = 0;
70
+ leavePromise;
71
+ heartbeatTimer;
72
+ currentPresence;
73
+ participantCatalogFull = false;
74
+ constructor(options) {
75
+ const nickname = normalizeNickname(options.nickname);
76
+ if (!nickname) throw new Error("Pi Chat nickname is invalid.");
77
+ this.room = options.room;
78
+ this.identity = options.identity;
79
+ this.nickname = nickname;
80
+ this.transport = options.transport;
81
+ this.now = options.now ?? Date.now;
82
+ this.onChange = options.onChange;
83
+ }
84
+ async start(signal) {
85
+ if (this.state !== "disconnected" || this.leavePromise) {
86
+ throw new Error("Pi Chat session has already started.");
87
+ }
88
+ const owner = ++this.generation;
89
+ this.state = "connecting";
90
+ this.emit();
91
+ try {
92
+ await this.transport.start(
93
+ {
94
+ onPeer: (peer) => this.onPeer(owner, peer),
95
+ onMessage: (peer, message) => this.onMessage(owner, peer, message),
96
+ onDisconnect: (peer) => this.onDisconnect(owner, peer),
97
+ onError: (error) => this.onError(owner, error)
98
+ },
99
+ signal
100
+ );
101
+ signal?.throwIfAborted();
102
+ if (owner !== this.generation) return;
103
+ this.state = "connected";
104
+ this.startHeartbeat(owner);
105
+ this.emit();
106
+ } catch (error) {
107
+ if (owner === this.generation) {
108
+ this.state = "disconnected";
109
+ this.lastError = safeError(error);
110
+ this.emit();
111
+ }
112
+ await this.transport.stop().catch(() => void 0);
113
+ throw error;
114
+ }
115
+ }
116
+ send(text) {
117
+ if (this.state !== "connected" && this.state !== "degraded") {
118
+ throw new Error("Pi Chat is not connected.");
119
+ }
120
+ const id = randomUUID();
121
+ const event = createChatEvent(this.room, this.identity, this.nickname, text, this.now(), id);
122
+ this.remember(eventKey(event));
123
+ const relayedTo = this.broadcast(createGossipMessage(event));
124
+ this.pushTranscript({
125
+ id,
126
+ author: "local",
127
+ label: formatIdentityLabel(this.nickname, this.identity.publicKey),
128
+ publicKey: this.identity.publicKey.toString("hex"),
129
+ text,
130
+ sentAt: event.issuedAt,
131
+ delivery: relayedTo > 0 ? "relayed" : "not-relayed",
132
+ relayedTo
133
+ });
134
+ this.emit();
135
+ return { id, relayedTo };
136
+ }
137
+ updateNickname(value) {
138
+ const nickname = normalizeNickname(value);
139
+ if (!nickname) throw new Error("Pi Chat nickname is invalid.");
140
+ this.nickname = nickname;
141
+ this.publishPresence("online");
142
+ this.emit();
143
+ }
144
+ mute(publicKey) {
145
+ const id = keyId(publicKey);
146
+ if (!this.participants.has(id)) return;
147
+ this.mutedOrigins.add(id);
148
+ const participant = this.participants.get(id);
149
+ if (participant) participant.muted = true;
150
+ this.emit();
151
+ }
152
+ toggleMute(publicKey) {
153
+ const id = keyId(publicKey);
154
+ const participant = this.participants.get(id);
155
+ if (!participant) return void 0;
156
+ if (this.mutedOrigins.has(id)) {
157
+ this.mutedOrigins.delete(id);
158
+ participant.muted = false;
159
+ } else {
160
+ this.mutedOrigins.add(id);
161
+ participant.muted = true;
162
+ }
163
+ this.emit();
164
+ return participant.muted;
165
+ }
166
+ subscribe(listener) {
167
+ this.listeners.add(listener);
168
+ return () => this.listeners.delete(listener);
169
+ }
170
+ setViewOpen(open) {
171
+ if (this.viewOpen === open) return;
172
+ this.viewOpen = open;
173
+ if (open) this.unread = 0;
174
+ this.emit();
175
+ }
176
+ leave() {
177
+ if (this.leavePromise) return this.leavePromise;
178
+ this.leavePromise = this.leaveOwned();
179
+ return this.leavePromise;
180
+ }
181
+ snapshot() {
182
+ this.pruneParticipants();
183
+ const active = [...this.participants.entries()];
184
+ const tags = uniqueIdentityTags([
185
+ this.identity.publicKey,
186
+ ...active.map(([, value]) => value.publicKey)
187
+ ]);
188
+ const localKey = this.identity.publicKey.toString("hex");
189
+ const participants = active.map(([publicKey, value]) => ({
190
+ publicKey,
191
+ nickname: value.nickname,
192
+ label: `${value.nickname}~${tags.get(publicKey) ?? formatIdentityLabel(value.nickname, value.publicKey).split("~").at(-1)}`,
193
+ muted: value.muted
194
+ })).sort((left, right) => left.label.localeCompare(right.label));
195
+ return {
196
+ state: this.state,
197
+ room: this.room,
198
+ localLabel: `${this.nickname}~${tags.get(localKey) ?? formatIdentityLabel(this.nickname, this.identity.publicKey).split("~").at(-1)}`,
199
+ participants,
200
+ directNeighbors: [...this.peers.values()].filter(({ authenticated }) => authenticated).length,
201
+ participantCatalogFull: this.participantCatalogFull,
202
+ transcript: this.transcript.map((entry) => {
203
+ const tag = tags.get(entry.publicKey);
204
+ const nickname = entry.label.split("~", 1)[0] ?? entry.label;
205
+ return { ...entry, label: tag ? `${nickname}~${tag}` : entry.label };
206
+ }),
207
+ unread: this.unread,
208
+ composerOpen: this.viewOpen,
209
+ ...this.lastError ? { lastError: this.lastError } : {}
210
+ };
211
+ }
212
+ onPeer(owner, peer) {
213
+ if (owner !== this.generation || this.state === "disconnected") {
214
+ peer.close();
215
+ return;
216
+ }
217
+ const id = keyId(peer.publicKey);
218
+ if (id === this.identity.publicKey.toString("hex")) {
219
+ peer.close();
220
+ return;
221
+ }
222
+ const previous = this.peers.get(id);
223
+ if (previous && previous.peer !== peer) previous.peer.close();
224
+ const state = {
225
+ peer,
226
+ authenticated: false,
227
+ nickname: previous?.nickname,
228
+ violations: 0,
229
+ limiter: new PeerRateLimiter({ burst: 12, refillPerSecond: 4, now: this.now })
230
+ };
231
+ this.peers.set(id, state);
232
+ try {
233
+ peer.send(
234
+ createHello(
235
+ this.room,
236
+ this.nickname,
237
+ this.identity.publicKey,
238
+ peer.publicKey,
239
+ randomBytes(16)
240
+ )
241
+ );
242
+ } catch {
243
+ peer.close();
244
+ this.peers.delete(id);
245
+ }
246
+ }
247
+ onMessage(owner, peer, message) {
248
+ if (owner !== this.generation) return;
249
+ const id = keyId(peer.publicKey);
250
+ const state = this.peers.get(id);
251
+ if (!state || state.peer !== peer) return;
252
+ if (!state.authenticated) {
253
+ const hello = verifyHello(message, this.room, peer.publicKey, this.identity.publicKey);
254
+ if (!hello) {
255
+ this.violate(id, state);
256
+ return;
257
+ }
258
+ state.authenticated = true;
259
+ state.nickname = hello.nickname;
260
+ this.upsertParticipant(id, peer.publicKey, hello.nickname, this.now());
261
+ this.sendPresenceTo(state.peer);
262
+ this.emit();
263
+ return;
264
+ }
265
+ if (message.type === "hello") return;
266
+ if (message.type === "goodbye") {
267
+ this.peers.delete(id);
268
+ peer.close();
269
+ this.emit();
270
+ return;
271
+ }
272
+ if (message.type !== "gossip") {
273
+ this.violate(id, state);
274
+ return;
275
+ }
276
+ this.onGossip(id, state, message);
277
+ }
278
+ onGossip(peerId, state, message) {
279
+ const event = message.event;
280
+ const key = eventKey(event);
281
+ if (event.origin === this.identity.publicKey.toString("hex") || this.hasSeen(key)) return;
282
+ if (!state.limiter.accept()) {
283
+ this.violate(peerId, state);
284
+ return;
285
+ }
286
+ if (!verifyRoomEvent(event, this.room, this.now())) {
287
+ this.violate(peerId, state);
288
+ return;
289
+ }
290
+ if (!this.acceptOrigin(event.origin)) return;
291
+ this.remember(key);
292
+ if (!this.applyEvent(event)) return;
293
+ if (message.hops > 1) {
294
+ this.broadcast(createGossipMessage(event, message.hops - 1), state.peer);
295
+ }
296
+ }
297
+ applyEvent(event) {
298
+ const publicKey = Buffer.from(event.origin, "hex");
299
+ const participantStateIsNew = this.acceptParticipantVersion(event);
300
+ if (event.kind === "presence") {
301
+ if (!participantStateIsNew) return false;
302
+ if (event.status === "leaving") {
303
+ this.participants.delete(event.origin);
304
+ this.originLimiters.delete(event.origin);
305
+ } else {
306
+ this.upsertParticipant(event.origin, publicKey, event.nickname, this.now());
307
+ }
308
+ this.emit();
309
+ return true;
310
+ }
311
+ if (participantStateIsNew) {
312
+ this.upsertParticipant(event.origin, publicKey, event.nickname, this.now());
313
+ }
314
+ if (!this.mutedOrigins.has(event.origin)) {
315
+ this.pushTranscript({
316
+ id: event.id,
317
+ author: "remote",
318
+ label: formatIdentityLabel(event.nickname, publicKey),
319
+ publicKey: event.origin,
320
+ text: event.text,
321
+ sentAt: event.issuedAt
322
+ });
323
+ if (!this.viewOpen) this.unread += 1;
324
+ }
325
+ this.emit();
326
+ return true;
327
+ }
328
+ acceptParticipantVersion(event) {
329
+ this.pruneParticipantVersions();
330
+ const existing = this.participantVersions.get(event.origin);
331
+ if (existing && compareEventVersion(existing, event) >= 0) return false;
332
+ if (!existing && this.participantVersions.size >= MAX_SEEN_MESSAGES) {
333
+ let oldestOrigin;
334
+ let oldestVersion;
335
+ for (const [origin, candidate] of this.participantVersions) {
336
+ if (!oldestVersion || compareEventVersion(candidate, oldestVersion) < 0) {
337
+ oldestOrigin = origin;
338
+ oldestVersion = candidate;
339
+ }
340
+ }
341
+ if (oldestOrigin) this.participantVersions.delete(oldestOrigin);
342
+ }
343
+ this.participantVersions.set(event.origin, {
344
+ issuedAt: event.issuedAt,
345
+ id: event.id
346
+ });
347
+ return true;
348
+ }
349
+ pruneParticipantVersions() {
350
+ const oldest = this.now() - MAX_EVENT_AGE_MS;
351
+ for (const [origin, version] of this.participantVersions) {
352
+ if (version.issuedAt < oldest) this.participantVersions.delete(origin);
353
+ }
354
+ }
355
+ onDisconnect(owner, peer) {
356
+ if (owner !== this.generation) return;
357
+ const id = keyId(peer.publicKey);
358
+ if (this.peers.get(id)?.peer === peer) {
359
+ this.peers.delete(id);
360
+ this.emit();
361
+ }
362
+ }
363
+ onError(owner, error) {
364
+ if (owner !== this.generation) return;
365
+ this.state = "degraded";
366
+ this.lastError = safeError(error);
367
+ this.emit();
368
+ }
369
+ startHeartbeat(owner) {
370
+ this.heartbeatTimer = setInterval(() => {
371
+ if (owner !== this.generation || this.state === "disconnected") return;
372
+ this.publishPresence("online");
373
+ this.pruneParticipants();
374
+ this.emit();
375
+ }, PRESENCE_HEARTBEAT_MS);
376
+ this.heartbeatTimer.unref();
377
+ }
378
+ publishPresence(status) {
379
+ const event = this.newPresence(status);
380
+ this.broadcast(createGossipMessage(event));
381
+ }
382
+ sendPresenceTo(peer) {
383
+ const event = this.currentPresence ?? this.newPresence("online");
384
+ try {
385
+ peer.send(createGossipMessage(event));
386
+ } catch {
387
+ }
388
+ }
389
+ newPresence(status) {
390
+ const event = createPresenceEvent(
391
+ this.room,
392
+ this.identity,
393
+ this.nickname,
394
+ status,
395
+ this.now(),
396
+ randomUUID()
397
+ );
398
+ this.currentPresence = status === "online" ? event : void 0;
399
+ this.remember(eventKey(event));
400
+ return event;
401
+ }
402
+ broadcast(message, exclude) {
403
+ let relayedTo = 0;
404
+ for (const state of this.peers.values()) {
405
+ if (!state.authenticated || state.peer === exclude) continue;
406
+ try {
407
+ state.peer.send(message);
408
+ relayedTo += 1;
409
+ } catch {
410
+ state.violations += 1;
411
+ }
412
+ }
413
+ return relayedTo;
414
+ }
415
+ upsertParticipant(id, publicKey, nickname, lastSeen) {
416
+ const existing = this.participants.get(id);
417
+ if (!existing && this.participants.size >= MAX_PARTICIPANTS) {
418
+ this.participantCatalogFull = true;
419
+ return;
420
+ }
421
+ this.participants.set(id, {
422
+ publicKey: Buffer.from(publicKey),
423
+ nickname,
424
+ muted: this.mutedOrigins.has(id),
425
+ lastSeen
426
+ });
427
+ }
428
+ pruneParticipants() {
429
+ this.pruneParticipantVersions();
430
+ const oldest = this.now() - PARTICIPANT_TTL_MS;
431
+ for (const [id, participant] of this.participants) {
432
+ if (participant.lastSeen < oldest) {
433
+ this.participants.delete(id);
434
+ this.originLimiters.delete(id);
435
+ }
436
+ }
437
+ if (this.participants.size < MAX_PARTICIPANTS) this.participantCatalogFull = false;
438
+ }
439
+ acceptOrigin(origin) {
440
+ const current = this.now();
441
+ let state = this.originLimiters.get(origin);
442
+ if (!state) {
443
+ if (this.originLimiters.size >= MAX_ORIGIN_LIMITERS) {
444
+ let oldestKey;
445
+ let oldest = Number.POSITIVE_INFINITY;
446
+ for (const [key, candidate] of this.originLimiters) {
447
+ if (candidate.lastSeen < oldest) {
448
+ oldest = candidate.lastSeen;
449
+ oldestKey = key;
450
+ }
451
+ }
452
+ if (oldestKey) this.originLimiters.delete(oldestKey);
453
+ }
454
+ state = {
455
+ limiter: new PeerRateLimiter({ burst: 6, refillPerSecond: 1, now: this.now }),
456
+ lastSeen: current
457
+ };
458
+ this.originLimiters.set(origin, state);
459
+ }
460
+ state.lastSeen = current;
461
+ return state.limiter.accept();
462
+ }
463
+ hasSeen(key) {
464
+ this.pruneSeen();
465
+ return this.seen.has(key);
466
+ }
467
+ remember(key) {
468
+ this.pruneSeen();
469
+ const expiresAt = this.now() + SEEN_MESSAGE_TTL_MS;
470
+ this.seen.set(key, expiresAt);
471
+ this.seenOrder.push({ key, expiresAt });
472
+ while (this.seen.size > MAX_SEEN_MESSAGES) {
473
+ const removed = this.seenOrder.shift();
474
+ if (removed && this.seen.get(removed.key) === removed.expiresAt) {
475
+ this.seen.delete(removed.key);
476
+ }
477
+ }
478
+ }
479
+ pruneSeen() {
480
+ const current = this.now();
481
+ while (this.seenOrder[0] && this.seenOrder[0].expiresAt <= current) {
482
+ const removed = this.seenOrder.shift();
483
+ if (removed && this.seen.get(removed.key) === removed.expiresAt) {
484
+ this.seen.delete(removed.key);
485
+ }
486
+ }
487
+ }
488
+ violate(id, state) {
489
+ state.violations += 1;
490
+ if (state.violations > MAX_PROTOCOL_VIOLATIONS) {
491
+ state.peer.close();
492
+ this.peers.delete(id);
493
+ this.emit();
494
+ }
495
+ }
496
+ pushTranscript(entry) {
497
+ this.transcript.push(entry);
498
+ if (this.transcript.length > MAX_TRANSCRIPT) this.transcript.shift();
499
+ }
500
+ async leaveOwned() {
501
+ this.generation += 1;
502
+ if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
503
+ this.heartbeatTimer = void 0;
504
+ if (this.state !== "disconnected") this.publishPresence("leaving");
505
+ for (const state of this.peers.values()) {
506
+ if (state.authenticated) {
507
+ try {
508
+ state.peer.send({ v: 2, type: "goodbye" });
509
+ } catch {
510
+ }
511
+ }
512
+ state.peer.close();
513
+ }
514
+ this.peers.clear();
515
+ this.participants.clear();
516
+ this.originLimiters.clear();
517
+ this.participantVersions.clear();
518
+ this.seen.clear();
519
+ this.seenOrder.length = 0;
520
+ await this.transport.stop().catch((error) => {
521
+ this.lastError = safeError(error);
522
+ });
523
+ this.state = "disconnected";
524
+ this.unread = 0;
525
+ this.transcript.length = 0;
526
+ this.emit();
527
+ }
528
+ emit() {
529
+ const snapshot = this.snapshot();
530
+ this.onChange?.(snapshot);
531
+ for (const listener of this.listeners) listener(snapshot);
532
+ }
533
+ };
534
+ function eventKey(event) {
535
+ return `${event.origin}:${event.id}`;
536
+ }
537
+ function compareEventVersion(left, right) {
538
+ return left.issuedAt - right.issuedAt || left.id.localeCompare(right.id);
539
+ }
540
+ function keyId(publicKey) {
541
+ return Buffer.from(publicKey).toString("hex");
542
+ }
543
+ function safeError(error) {
544
+ return error instanceof Error ? error.message : String(error);
545
+ }
546
+
547
+ // src/pi-chat.ts
548
+ var CHAT_UI_KEY = "chat";
549
+ var EXPERIMENTAL_WARNING = "Pi Chat is experimental. Peer identity, networking, and interaction behavior may change.";
550
+ var USAGE = "Usage: /chat, /chat <pichat:v1-or-v2:invite>, or /chat #<public-slug>";
551
+ var PRIVATE_ROOM_OPTIONS = [
552
+ "Join and remember \u2014 Save the bearer invite privately and restore this room",
553
+ "Join once \u2014 Do not save the bearer invite",
554
+ "Cancel"
555
+ ];
556
+ var DISPLAY_OPTIONS = [
557
+ {
558
+ label: "Room dock \u2014 Show up to three recent messages above the Pi editor",
559
+ mode: "dock"
560
+ },
561
+ { label: "Latest message \u2014 Show one recent message above the Pi editor", mode: "latest" },
562
+ { label: "Status only \u2014 Hide message text", mode: "count" },
563
+ { label: "Hidden \u2014 Show no persistent room widget", mode: "off" }
564
+ ];
565
+ function createPiChatExtension(dependencies = {}) {
566
+ const loadNetwork = cachedModuleLoader(() => import("./chunks/network-U5O6BOQN.js"));
567
+ const loadDirectoryNetwork = cachedModuleLoader(() => import("./chunks/directory-network-OV6FYWIK.js"));
568
+ const deps = {
569
+ settingsPath: dependencies.settingsPath ?? chatSettingsPath(),
570
+ randomBytes: dependencies.randomBytes ?? nodeRandomBytes,
571
+ createTransport: dependencies.createTransport ?? (async (options) => {
572
+ const { HyperswarmTransport } = await loadNetwork();
573
+ return new HyperswarmTransport(options);
574
+ }),
575
+ createDirectory: dependencies.createDirectory ?? (async (options) => {
576
+ const { HyperswarmDirectoryTransport, PublicRoomDirectorySession } = await loadDirectoryNetwork();
577
+ return new PublicRoomDirectorySession({
578
+ ...options,
579
+ transport: new HyperswarmDirectoryTransport({ identity: options.identity })
580
+ });
581
+ }),
582
+ updateSettings: dependencies.updateSettings ?? updateChatSettings,
583
+ loadChatMenu: cachedModuleLoader(dependencies.loadChatMenu ?? (() => import("./chunks/menu-6KBWK6KS.js"))),
584
+ loadChatView: cachedModuleLoader(dependencies.loadChatView ?? (() => import("./chunks/chat-view-QEAZMMXC.js"))),
585
+ loadChatWidget: cachedModuleLoader(
586
+ dependencies.loadChatWidget ?? (() => import("./chunks/widget-ER6SODIX.js"))
587
+ )
588
+ };
589
+ const updateChatSettings2 = deps.updateSettings;
590
+ return function piChatExtension(pi) {
591
+ let generation = 0;
592
+ let controller = new AbortController();
593
+ let activeSessionManager;
594
+ let activeContext;
595
+ let settings = {};
596
+ let chatSession;
597
+ let roomDirectory;
598
+ let latestSnapshot;
599
+ let chatDraft = "";
600
+ let restoreError;
601
+ let restoringRoomId;
602
+ let joinOwner;
603
+ const ownedTasks = /* @__PURE__ */ new Set();
604
+ let renderChatWidget;
605
+ let widgetRender;
606
+ let widgetInstalled = false;
607
+ const isCurrent = (owner, ownerGeneration) => activeSessionManager === owner && generation === ownerGeneration && !controller.signal.aborted;
608
+ const trackTask = (task) => {
609
+ ownedTasks.add(task);
610
+ void task.then(
611
+ () => ownedTasks.delete(task),
612
+ () => ownedTasks.delete(task)
613
+ );
614
+ return task;
615
+ };
616
+ const drainOwnedTasks = async () => {
617
+ while (ownedTasks.size > 0) await Promise.allSettled([...ownedTasks]);
618
+ };
619
+ const clearUi = (ctx, ownerGeneration = generation) => {
620
+ try {
621
+ ctx.ui.setWidget(CHAT_UI_KEY, void 0);
622
+ ctx.ui.setStatus(CHAT_UI_KEY, void 0);
623
+ } catch {
624
+ }
625
+ if (ctx.sessionManager !== activeSessionManager || generation !== ownerGeneration) return;
626
+ renderChatWidget = void 0;
627
+ widgetRender = void 0;
628
+ widgetInstalled = false;
629
+ };
630
+ const updateUi = (ctx, snapshot) => {
631
+ if (ctx.sessionManager !== activeSessionManager) return;
632
+ latestSnapshot = snapshot;
633
+ try {
634
+ ctx.ui.setStatus(
635
+ CHAT_UI_KEY,
636
+ snapshot?.state === "connecting" ? restoringRoomId === snapshot.room.id ? `chat: restoring ${sanitizeSingleLine(snapshot.room.label)}` : "chat: joining" : snapshot?.state === "degraded" ? "chat: reconnecting" : void 0
637
+ );
638
+ const mode = settings.widgetMode ?? "count";
639
+ if (ctx.mode !== "tui" || !snapshot || snapshot.state === "disconnected" || mode === "off") {
640
+ ctx.ui.setWidget(CHAT_UI_KEY, void 0);
641
+ widgetInstalled = false;
642
+ widgetRender = void 0;
643
+ return;
644
+ }
645
+ const renderWidget = renderChatWidget;
646
+ if (!renderWidget) return;
647
+ if (!widgetInstalled) {
648
+ ctx.ui.setWidget(CHAT_UI_KEY, (tui, theme) => {
649
+ const requestRender = () => tui.requestRender();
650
+ widgetRender = requestRender;
651
+ return {
652
+ render: (width) => latestSnapshot ? renderWidget(
653
+ latestSnapshot,
654
+ settings.widgetMode ?? "count",
655
+ width,
656
+ theme,
657
+ tui.terminal.rows
658
+ ) : [],
659
+ invalidate() {
660
+ },
661
+ dispose() {
662
+ if (widgetRender === requestRender) widgetRender = void 0;
663
+ }
664
+ };
665
+ });
666
+ widgetInstalled = true;
667
+ }
668
+ widgetRender?.();
669
+ } catch {
670
+ }
671
+ };
672
+ const disconnectRoom = async () => {
673
+ const owned = chatSession;
674
+ const ownedDirectory = roomDirectory;
675
+ const uiContext = activeContext;
676
+ const uiGeneration = generation;
677
+ chatSession = void 0;
678
+ roomDirectory = void 0;
679
+ latestSnapshot = void 0;
680
+ chatDraft = "";
681
+ await Promise.allSettled([owned?.leave(), ownedDirectory?.stop()]);
682
+ if (uiContext) clearUi(uiContext, uiGeneration);
683
+ };
684
+ const ensureIdentity = async (ctx, signal, owner, ownerGeneration) => {
685
+ let nickname = settings.nickname;
686
+ if (!nickname) {
687
+ const entered = await ctx.ui.input(
688
+ "Choose a Pi Chat nickname",
689
+ "Visible to room peers; no OS or Git identity is used",
690
+ { signal }
691
+ );
692
+ if (!isCurrent(owner, ownerGeneration) || signal.aborted || !entered) return void 0;
693
+ nickname = entered;
694
+ }
695
+ let seed = settings.identitySeed;
696
+ let widgetMode = settings.widgetMode;
697
+ if (!seed) {
698
+ const candidate = createIdentity(deps.randomBytes(32));
699
+ if (!widgetMode) {
700
+ const selected = await ctx.ui.select(
701
+ "Joined room display",
702
+ DISPLAY_OPTIONS.map(({ label }) => label),
703
+ { signal }
704
+ );
705
+ if (!selected || !isCurrent(owner, ownerGeneration) || signal.aborted) return void 0;
706
+ widgetMode = DISPLAY_OPTIONS.find(({ label }) => label === selected)?.mode;
707
+ if (!widgetMode) return void 0;
708
+ }
709
+ const display = DISPLAY_OPTIONS.find(({ mode }) => mode === widgetMode)?.label ?? widgetMode;
710
+ const confirmed = await ctx.ui.confirm(
711
+ "Create Pi Chat identity?",
712
+ `${formatIdentityLabel(nickname, candidate.publicKey)}
713
+ Display: ${display}
714
+ This pseudonymous fingerprint is not real-world identity verification.`,
715
+ { signal }
716
+ );
717
+ if (!confirmed || !isCurrent(owner, ownerGeneration) || signal.aborted) return void 0;
718
+ seed = candidate.seed;
719
+ }
720
+ if (nickname !== settings.nickname || seed !== settings.identitySeed || widgetMode !== settings.widgetMode) {
721
+ const updated = await updateChatSettings2(
722
+ {
723
+ nickname,
724
+ identitySeed: seed,
725
+ ...widgetMode ? { widgetMode } : {}
726
+ },
727
+ { settingsPath: deps.settingsPath, signal }
728
+ );
729
+ if (!isCurrent(owner, ownerGeneration)) return void 0;
730
+ settings = updated;
731
+ }
732
+ return createIdentity(Buffer.from(seed, "base64url"));
733
+ };
734
+ const startPublicRoomDirectory = (room, identity, session, ctx, owner, ownerGeneration) => {
735
+ if (room.kind !== "public" || !room.slug) return;
736
+ void trackTask(
737
+ (async () => {
738
+ let directory;
739
+ try {
740
+ directory = await deps.createDirectory({
741
+ identity: deriveScopedIdentity(identity, `directory:#${room.slug}`),
742
+ advertisedSlug: room.slug
743
+ });
744
+ if (!isCurrent(owner, ownerGeneration) || controller.signal.aborted || chatSession !== session) {
745
+ await directory.stop();
746
+ return;
747
+ }
748
+ roomDirectory = directory;
749
+ await directory.start(controller.signal);
750
+ } catch (error) {
751
+ const ownsDirectory = !directory || roomDirectory === directory;
752
+ if (directory && roomDirectory === directory) roomDirectory = void 0;
753
+ if (directory) await Promise.allSettled([directory.stop()]);
754
+ if (ownsDirectory && isCurrent(owner, ownerGeneration) && chatSession === session && session.snapshot().room.id === room.id) {
755
+ notifySafely(
756
+ ctx,
757
+ `Pi Chat public-room discovery is unavailable: ${sanitizeSingleLine(
758
+ error instanceof Error ? error.message : String(error)
759
+ )}. Chat remains connected.`,
760
+ "warning"
761
+ );
762
+ }
763
+ }
764
+ })()
765
+ );
766
+ };
767
+ const joinRoomOwned = async (room, ctx, signal, options) => {
768
+ if (chatSession && latestSnapshot?.state !== "disconnected") {
769
+ throw new Error("Leave the current Pi Chat room before joining another.");
770
+ }
771
+ const owner = ctx.sessionManager;
772
+ const ownerGeneration = generation;
773
+ if (!isCurrent(owner, ownerGeneration)) throw new Error("Pi Chat session is stale.");
774
+ let remember = options?.remember ?? false;
775
+ if (room.kind === "private" && options === void 0) {
776
+ const selected = await ctx.ui.select(
777
+ "Private bearer invite \u2014 restore this room after restarting Pi?",
778
+ [...PRIVATE_ROOM_OPTIONS],
779
+ { signal }
780
+ );
781
+ if (!selected || selected === PRIVATE_ROOM_OPTIONS[2] || !isCurrent(owner, ownerGeneration) || signal.aborted) {
782
+ return false;
783
+ }
784
+ remember = selected === PRIVATE_ROOM_OPTIONS[0];
785
+ }
786
+ const identity = await ensureIdentity(ctx, signal, owner, ownerGeneration);
787
+ if (!identity || !isCurrent(owner, ownerGeneration) || signal.aborted) return false;
788
+ const nickname = settings.nickname;
789
+ if (!nickname) throw new Error("Pi Chat nickname is unavailable.");
790
+ const widgetModule = await loadOwnedModule(
791
+ deps.loadChatWidget,
792
+ () => isCurrent(owner, ownerGeneration) && !signal.aborted
793
+ );
794
+ if (!widgetModule) return false;
795
+ let transport;
796
+ try {
797
+ transport = await deps.createTransport({
798
+ room,
799
+ identity,
800
+ maxPeers: MAX_DIRECT_NEIGHBORS
801
+ });
802
+ } catch (error) {
803
+ if (!isCurrent(owner, ownerGeneration) || signal.aborted) return false;
804
+ throw error;
805
+ }
806
+ if (!isCurrent(owner, ownerGeneration) || signal.aborted) {
807
+ await transport.stop();
808
+ return false;
809
+ }
810
+ renderChatWidget = widgetModule.renderChatWidget;
811
+ const session = new ChatSession({
812
+ room,
813
+ identity,
814
+ nickname,
815
+ transport,
816
+ onChange: (snapshot) => {
817
+ if (chatSession !== session || !isCurrent(owner, ownerGeneration)) return;
818
+ updateUi(ctx, snapshot);
819
+ }
820
+ });
821
+ chatSession = session;
822
+ ctx.ui.setStatus(CHAT_UI_KEY, "chat: joining");
823
+ try {
824
+ await session.start(AbortSignal.any([signal, controller.signal]));
825
+ if (!isCurrent(owner, ownerGeneration) || chatSession !== session) {
826
+ await session.leave();
827
+ return false;
828
+ }
829
+ if (remember) {
830
+ const rememberedRoom = rememberedRoomFromDescriptor(room);
831
+ const next = await updateChatSettings2(
832
+ {
833
+ resume: {
834
+ rooms: [rememberedRoom],
835
+ activeRoomId: rememberedRoom.id,
836
+ surface: "chat"
837
+ }
838
+ },
839
+ { settingsPath: deps.settingsPath, signal }
840
+ );
841
+ if (!isCurrent(owner, ownerGeneration) || chatSession !== session) {
842
+ await session.leave();
843
+ return false;
844
+ }
845
+ settings = next;
846
+ }
847
+ restoreError = void 0;
848
+ latestSnapshot = session.snapshot();
849
+ updateUi(ctx, latestSnapshot);
850
+ startPublicRoomDirectory(room, identity, session, ctx, owner, ownerGeneration);
851
+ return true;
852
+ } catch (error) {
853
+ if (chatSession === session) chatSession = void 0;
854
+ await session.leave();
855
+ clearUi(ctx, ownerGeneration);
856
+ if (!signal.aborted && isCurrent(owner, ownerGeneration)) throw error;
857
+ return false;
858
+ }
859
+ };
860
+ const joinRoom = async (room, ctx, signal, options) => {
861
+ const existing = joinOwner;
862
+ if (existing?.sessionManager === ctx.sessionManager && existing.generation === generation) {
863
+ throw new Error("A Pi Chat room join is already in progress.");
864
+ }
865
+ const token = /* @__PURE__ */ Symbol("chat-join");
866
+ joinOwner = { sessionManager: ctx.sessionManager, generation, token };
867
+ try {
868
+ return await joinRoomOwned(room, ctx, signal, options);
869
+ } finally {
870
+ if (joinOwner?.token === token) joinOwner = void 0;
871
+ }
872
+ };
873
+ const updateRememberedSurface = async (surface, ctx, owner, ownerGeneration, session) => {
874
+ const resume = settings.resume;
875
+ if (!resume || resume.activeRoomId !== session.snapshot().room.id || resume.surface === surface) {
876
+ return;
877
+ }
878
+ try {
879
+ const next = await updateChatSettings2(
880
+ { resume: { ...resume, surface } },
881
+ { settingsPath: deps.settingsPath, signal: controller.signal }
882
+ );
883
+ if (isCurrent(owner, ownerGeneration) && chatSession === session) settings = next;
884
+ } catch (error) {
885
+ if (isCurrent(owner, ownerGeneration) && chatSession === session) {
886
+ notifySafely(
887
+ ctx,
888
+ `Pi Chat could not save the restart view: ${sanitizeSingleLine(error instanceof Error ? error.message : String(error))}.`,
889
+ "error"
890
+ );
891
+ }
892
+ }
893
+ };
894
+ const openChat = async (ctx) => {
895
+ const session = chatSession;
896
+ if (!session || session.snapshot().state === "disconnected") {
897
+ throw new Error("Join a Pi Chat room first.");
898
+ }
899
+ const owner = ctx.sessionManager;
900
+ const ownerGeneration = generation;
901
+ const ownerSignal = controller.signal;
902
+ await updateRememberedSurface("chat", ctx, owner, ownerGeneration, session);
903
+ if (!isCurrent(owner, ownerGeneration) || chatSession !== session) return;
904
+ const viewModule = await loadOwnedModule(
905
+ deps.loadChatView,
906
+ () => isCurrent(owner, ownerGeneration) && chatSession === session
907
+ );
908
+ if (!viewModule) return;
909
+ const { ChatView } = viewModule;
910
+ await ctx.ui.custom(
911
+ (tui, theme, _keybindings, done) => new ChatView({
912
+ tui,
913
+ theme,
914
+ getSnapshot: () => session.snapshot(),
915
+ send: (text) => session.send(text),
916
+ initialDraft: chatDraft,
917
+ onDraftChange: (text) => {
918
+ if (isCurrent(owner, ownerGeneration) && chatSession === session) chatDraft = text;
919
+ },
920
+ setViewOpen: (open) => session.setViewOpen(open),
921
+ subscribe: (listener) => session.subscribe(listener),
922
+ signal: ownerSignal,
923
+ onReturnToPi: () => {
924
+ void trackTask(updateRememberedSurface("pi", ctx, owner, ownerGeneration, session));
925
+ },
926
+ onClose: () => done(void 0)
927
+ })
928
+ );
929
+ if (isCurrent(owner, ownerGeneration) && chatSession === session)
930
+ updateUi(ctx, session.snapshot());
931
+ };
932
+ const restoreRememberedRoom = async (ctx, ownerGeneration, signal = controller.signal) => {
933
+ const resume = settings.resume;
934
+ if (!resume || !settings.nickname || !settings.identitySeed || ctx.mode !== "tui") return;
935
+ const remembered = resume.rooms.find(({ id }) => id === resume.activeRoomId);
936
+ if (!remembered || !isCurrent(ctx.sessionManager, ownerGeneration)) return;
937
+ let room;
938
+ try {
939
+ room = descriptorFromRememberedRoom(remembered);
940
+ } catch {
941
+ notifySafely(ctx, "Pi Chat could not restore the saved room; fix pi-chat.json.", "error");
942
+ return;
943
+ }
944
+ restoreError = void 0;
945
+ restoringRoomId = room.id;
946
+ try {
947
+ ctx.ui.setStatus(CHAT_UI_KEY, `chat: restoring ${sanitizeSingleLine(room.label)}`);
948
+ const joined = await joinRoom(room, ctx, signal, { remember: false });
949
+ if (!joined || signal.aborted || !isCurrent(ctx.sessionManager, ownerGeneration)) return;
950
+ if (resume.surface === "chat") await openChat(ctx);
951
+ } catch (error) {
952
+ if (isCurrent(ctx.sessionManager, ownerGeneration)) {
953
+ restoreError = sanitizeSingleLine(error instanceof Error ? error.message : String(error));
954
+ ctx.ui.setStatus(CHAT_UI_KEY, "chat: restore failed");
955
+ notifySafely(
956
+ ctx,
957
+ `Pi Chat could not restore ${sanitizeSingleLine(room.label)}: ${restoreError}. Use /chat to retry or forget it.`,
958
+ "error"
959
+ );
960
+ }
961
+ } finally {
962
+ if (restoringRoomId === room.id) restoringRoomId = void 0;
963
+ }
964
+ };
965
+ const menuSource = (ctx) => {
966
+ const resetIdentity = createIdentity(deps.randomBytes(32));
967
+ const owner = ctx.sessionManager;
968
+ const ownerGeneration = generation;
969
+ const ownsMenu = () => isCurrent(owner, ownerGeneration);
970
+ return {
971
+ settingsPath: deps.settingsPath,
972
+ getSettings: () => settings,
973
+ getSnapshot: () => chatSession?.snapshot(),
974
+ getRestoreError: () => restoreError,
975
+ createPrivateRoom: () => createPrivateRoom(deps.randomBytes(32)),
976
+ browsePublicRooms: async (signal) => {
977
+ if (!ownsMenu()) throw new Error("Pi Chat session is stale.");
978
+ const activeDirectory = roomDirectory;
979
+ const directory = activeDirectory ?? await deps.createDirectory({ identity: createIdentity(deps.randomBytes(32)) });
980
+ const temporary = activeDirectory ? void 0 : directory;
981
+ const browseSignal = AbortSignal.any([signal, controller.signal]);
982
+ if (!ownsMenu() || browseSignal.aborted) {
983
+ if (temporary) await temporary.stop();
984
+ throw browseSignal.reason ?? new DOMException("Aborted", "AbortError");
985
+ }
986
+ try {
987
+ const result = await directory.browse(browseSignal);
988
+ if (!ownsMenu() || browseSignal.aborted) {
989
+ throw browseSignal.reason ?? new DOMException("Aborted", "AbortError");
990
+ }
991
+ return result;
992
+ } finally {
993
+ if (temporary) await temporary.stop();
994
+ }
995
+ },
996
+ joinRoom,
997
+ openChat: async (commandCtx) => {
998
+ if (ownsMenu()) await openChat(commandCtx);
999
+ },
1000
+ retryRememberedRoom: async (commandCtx, signal) => {
1001
+ if (!ownsMenu() || signal.aborted) return;
1002
+ await restoreRememberedRoom(
1003
+ commandCtx,
1004
+ ownerGeneration,
1005
+ AbortSignal.any([signal, controller.signal])
1006
+ );
1007
+ if (restoreError) throw new Error(restoreError);
1008
+ },
1009
+ forgetRememberedRoom: async (signal) => {
1010
+ if (!ownsMenu()) return;
1011
+ if (settings.resume) {
1012
+ const next = await updateChatSettings2(
1013
+ { resume: null },
1014
+ { settingsPath: deps.settingsPath, signal }
1015
+ );
1016
+ if (!ownsMenu()) return;
1017
+ settings = next;
1018
+ }
1019
+ restoreError = void 0;
1020
+ clearUi(ctx);
1021
+ },
1022
+ leaveRoom: async (signal) => {
1023
+ if (!ownsMenu()) return;
1024
+ const currentRoomId = chatSession?.snapshot().room.id;
1025
+ if (settings.resume && settings.resume.activeRoomId === currentRoomId) {
1026
+ const next = await updateChatSettings2(
1027
+ { resume: null },
1028
+ { settingsPath: deps.settingsPath, signal }
1029
+ );
1030
+ if (!ownsMenu()) return;
1031
+ settings = next;
1032
+ }
1033
+ restoreError = void 0;
1034
+ await disconnectRoom();
1035
+ },
1036
+ toggleMute(publicKey) {
1037
+ if (!ownsMenu() || !/^[0-9a-f]{64}$/u.test(publicKey)) return void 0;
1038
+ const muted = chatSession?.toggleMute(Buffer.from(publicKey, "hex"));
1039
+ if (chatSession) updateUi(ctx, chatSession.snapshot());
1040
+ return muted;
1041
+ },
1042
+ async updateNickname(value, signal) {
1043
+ const previous = settings;
1044
+ const next = await updateChatSettings2(
1045
+ { nickname: value },
1046
+ { settingsPath: deps.settingsPath, signal }
1047
+ );
1048
+ if (!ownsMenu()) return;
1049
+ settings = next;
1050
+ try {
1051
+ chatSession?.updateNickname(value);
1052
+ } catch (error) {
1053
+ settings = previous;
1054
+ throw error;
1055
+ }
1056
+ if (chatSession) updateUi(ctx, chatSession.snapshot());
1057
+ },
1058
+ async updateWidgetMode(value, signal) {
1059
+ const next = await updateChatSettings2(
1060
+ { widgetMode: value },
1061
+ { settingsPath: deps.settingsPath, signal }
1062
+ );
1063
+ if (!ownsMenu()) return;
1064
+ settings = next;
1065
+ updateUi(ctx, chatSession?.snapshot());
1066
+ },
1067
+ getIdentityResetPreview: () => {
1068
+ const current = settings.identitySeed ? formatIdentityLabel(
1069
+ settings.nickname ?? "anonymous",
1070
+ createIdentity(Buffer.from(settings.identitySeed, "base64url")).publicKey
1071
+ ) : "not created";
1072
+ return {
1073
+ current,
1074
+ next: formatIdentityLabel(settings.nickname ?? "anonymous", resetIdentity.publicKey)
1075
+ };
1076
+ },
1077
+ async resetIdentity(signal) {
1078
+ const next = await updateChatSettings2(
1079
+ { identitySeed: resetIdentity.seed, resume: null },
1080
+ { settingsPath: deps.settingsPath, signal }
1081
+ );
1082
+ if (!ownsMenu()) return;
1083
+ settings = next;
1084
+ await disconnectRoom();
1085
+ }
1086
+ };
1087
+ };
1088
+ pi.registerCommand("chat", {
1089
+ description: "Open experimental peer-to-peer developer chat",
1090
+ handler: async (args, ctx) => {
1091
+ if (ctx.mode !== "tui") throw new Error("Pi Chat requires Pi TUI mode.");
1092
+ const owner = ctx.sessionManager;
1093
+ const ownerGeneration = generation;
1094
+ if (!isCurrent(owner, ownerGeneration)) throw new Error("Pi Chat session is stale.");
1095
+ const input = args.trim();
1096
+ if (!input) {
1097
+ const menuModule = await loadOwnedModule(
1098
+ deps.loadChatMenu,
1099
+ () => isCurrent(owner, ownerGeneration)
1100
+ );
1101
+ if (!menuModule) return;
1102
+ const { showChatMenu } = menuModule;
1103
+ await showChatMenu(ctx, menuSource(ctx), {
1104
+ signal: controller.signal,
1105
+ isCurrent: () => isCurrent(owner, ownerGeneration)
1106
+ });
1107
+ return;
1108
+ }
1109
+ if (/\s/u.test(input)) {
1110
+ notifySafely(ctx, USAGE, "warning");
1111
+ return;
1112
+ }
1113
+ let room;
1114
+ let openAfterJoin = false;
1115
+ if (input.startsWith("pichat:")) {
1116
+ openAfterJoin = true;
1117
+ try {
1118
+ room = parseInvite(input);
1119
+ } catch {
1120
+ notifySafely(ctx, USAGE, "warning");
1121
+ return;
1122
+ }
1123
+ } else if (input.startsWith("#")) {
1124
+ openAfterJoin = true;
1125
+ try {
1126
+ room = createPublicRoom(input.slice(1));
1127
+ } catch {
1128
+ notifySafely(ctx, USAGE, "warning");
1129
+ return;
1130
+ }
1131
+ const confirmed = await ctx.ui.confirm(
1132
+ "Join public room?",
1133
+ "Anyone can join or record it. DHT and direct peers may observe network metadata.",
1134
+ { signal: controller.signal }
1135
+ );
1136
+ if (!confirmed || !isCurrent(owner, ownerGeneration)) return;
1137
+ } else {
1138
+ notifySafely(ctx, USAGE, "warning");
1139
+ return;
1140
+ }
1141
+ const joined = await joinRoom(
1142
+ room,
1143
+ ctx,
1144
+ controller.signal,
1145
+ room.kind === "public" ? { remember: true } : void 0
1146
+ );
1147
+ if (joined && openAfterJoin && !controller.signal.aborted && isCurrent(owner, ownerGeneration)) {
1148
+ await openChat(ctx);
1149
+ }
1150
+ }
1151
+ });
1152
+ pi.on("session_start", async (_event, ctx) => {
1153
+ controller.abort(new DOMException("Pi Chat session replaced", "AbortError"));
1154
+ await disconnectRoom();
1155
+ await drainOwnedTasks();
1156
+ controller = new AbortController();
1157
+ generation += 1;
1158
+ activeSessionManager = ctx.sessionManager;
1159
+ activeContext = ctx;
1160
+ restoreError = void 0;
1161
+ clearUi(ctx);
1162
+ const ownerGeneration = generation;
1163
+ const loaded = await readChatSettings(deps.settingsPath);
1164
+ if (generation !== ownerGeneration || activeSessionManager !== ctx.sessionManager) return;
1165
+ if (loaded.kind === "loaded") settings = loaded.settings;
1166
+ else if (loaded.kind === "missing") settings = {};
1167
+ else {
1168
+ settings = {};
1169
+ notifySafely(ctx, "Pi Chat settings are invalid; fix the file before saving.", "error");
1170
+ }
1171
+ if (ctx.hasUI) notifySafely(ctx, EXPERIMENTAL_WARNING, "warning");
1172
+ if (settings.resume && ctx.mode === "tui") {
1173
+ void trackTask(restoreRememberedRoom(ctx, ownerGeneration));
1174
+ }
1175
+ });
1176
+ pi.on("session_shutdown", async (_event, ctx) => {
1177
+ const owner = ctx.sessionManager;
1178
+ if (owner !== activeSessionManager) return;
1179
+ controller.abort(new DOMException("Pi Chat session shut down", "AbortError"));
1180
+ const shutdownGeneration = ++generation;
1181
+ await disconnectRoom();
1182
+ await drainOwnedTasks();
1183
+ await awaitChatSettingsWrites(deps.settingsPath);
1184
+ if (activeSessionManager !== owner || generation !== shutdownGeneration) return;
1185
+ clearUi(ctx);
1186
+ activeSessionManager = void 0;
1187
+ activeContext = void 0;
1188
+ });
1189
+ };
1190
+ }
1191
+ function notifySafely(ctx, message, level) {
1192
+ try {
1193
+ ctx.ui.notify(sanitizeSingleLine(message), level);
1194
+ } catch {
1195
+ }
1196
+ }
1197
+ async function loadOwnedModule(load, isCurrent) {
1198
+ try {
1199
+ const module = await load();
1200
+ return isCurrent() ? module : void 0;
1201
+ } catch (error) {
1202
+ if (!isCurrent()) return void 0;
1203
+ throw error;
1204
+ }
1205
+ }
1206
+ function cachedModuleLoader(load) {
1207
+ let pending;
1208
+ return () => {
1209
+ if (!pending) {
1210
+ pending = load().catch((error) => {
1211
+ pending = void 0;
1212
+ throw error;
1213
+ });
1214
+ }
1215
+ return pending;
1216
+ };
1217
+ }
1218
+ var pi_chat_default = createPiChatExtension();
1219
+ export {
1220
+ pi_chat_default as default
1221
+ };
1222
+ //# sourceMappingURL=index.ts.map