@narumitw/pi-chat 0.0.0

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/src/pi-chat.ts ADDED
@@ -0,0 +1,647 @@
1
+ import { randomBytes as nodeRandomBytes } from "node:crypto";
2
+ import type {
3
+ ExtensionAPI,
4
+ ExtensionCommandContext,
5
+ ExtensionContext,
6
+ } from "@earendil-works/pi-coding-agent";
7
+ import type { ChatSnapshot, ChatTransport } from "./chat-session.js";
8
+ import { ChatSession } from "./chat-session.js";
9
+ import { ChatView } from "./chat-view.js";
10
+ import { type ChatIdentity, createIdentity, formatIdentityLabel } from "./identity.js";
11
+ import { type ChatMenuSource, type JoinRoomOptions, showChatMenu } from "./menu.js";
12
+ import { HyperswarmTransport, type HyperswarmTransportOptions } from "./network.js";
13
+ import {
14
+ createPrivateRoom,
15
+ createPublicRoom,
16
+ parseInvite,
17
+ type RoomDescriptor,
18
+ } from "./protocol.js";
19
+ import {
20
+ awaitChatSettingsWrites,
21
+ type ChatSettings,
22
+ chatSettingsPath,
23
+ descriptorFromRememberedRoom,
24
+ readChatSettings,
25
+ rememberedRoomFromDescriptor,
26
+ updateChatSettings as updateChatSettingsFile,
27
+ type WidgetMode,
28
+ } from "./settings.js";
29
+ import { sanitizeSingleLine } from "./text.js";
30
+ import { renderChatWidget } from "./widget.js";
31
+
32
+ const CHAT_UI_KEY = "chat";
33
+ const EXPERIMENTAL_WARNING =
34
+ "Pi Chat is experimental. Peer identity, networking, and interaction behavior may change.";
35
+ const USAGE = "Usage: /chat, /chat <pichat:v1:invite>, or /chat #<public-slug>";
36
+ const PRIVATE_ROOM_OPTIONS = [
37
+ "Join and remember — Save the bearer invite privately and restore this room",
38
+ "Join once — Do not save the bearer invite",
39
+ "Cancel",
40
+ ] as const;
41
+ const DISPLAY_OPTIONS: ReadonlyArray<{ label: string; mode: WidgetMode }> = [
42
+ {
43
+ label: "Room dock — Show up to three recent messages above the Pi editor",
44
+ mode: "dock",
45
+ },
46
+ { label: "Latest message — Show one recent message above the Pi editor", mode: "latest" },
47
+ { label: "Status only — Hide message text", mode: "count" },
48
+ { label: "Hidden — Show no persistent room widget", mode: "off" },
49
+ ];
50
+
51
+ export interface PiChatDependencies {
52
+ settingsPath: string;
53
+ randomBytes(size: number): Buffer;
54
+ createTransport(options: HyperswarmTransportOptions): ChatTransport;
55
+ updateSettings: typeof updateChatSettingsFile;
56
+ }
57
+
58
+ export function createPiChatExtension(
59
+ dependencies: Partial<PiChatDependencies> = {},
60
+ ): (pi: ExtensionAPI) => void {
61
+ const deps: PiChatDependencies = {
62
+ settingsPath: dependencies.settingsPath ?? chatSettingsPath(),
63
+ randomBytes: dependencies.randomBytes ?? nodeRandomBytes,
64
+ createTransport:
65
+ dependencies.createTransport ?? ((options) => new HyperswarmTransport(options)),
66
+ updateSettings: dependencies.updateSettings ?? updateChatSettingsFile,
67
+ };
68
+ const updateChatSettings = deps.updateSettings;
69
+
70
+ return function piChatExtension(pi: ExtensionAPI): void {
71
+ let generation = 0;
72
+ let controller = new AbortController();
73
+ let activeSessionManager: unknown;
74
+ let activeContext: ExtensionContext | undefined;
75
+ let settings: ChatSettings = {};
76
+ let chatSession: ChatSession | undefined;
77
+ let latestSnapshot: ChatSnapshot | undefined;
78
+ let chatDraft = "";
79
+ let restoreError: string | undefined;
80
+ let restoringRoomId: string | undefined;
81
+ const ownedTasks = new Set<Promise<unknown>>();
82
+ let widgetRender: (() => void) | undefined;
83
+ let widgetInstalled = false;
84
+
85
+ const isCurrent = (owner: unknown, ownerGeneration: number) =>
86
+ activeSessionManager === owner &&
87
+ generation === ownerGeneration &&
88
+ !controller.signal.aborted;
89
+
90
+ const trackTask = <T>(task: Promise<T>): Promise<T> => {
91
+ ownedTasks.add(task);
92
+ void task.then(
93
+ () => ownedTasks.delete(task),
94
+ () => ownedTasks.delete(task),
95
+ );
96
+ return task;
97
+ };
98
+
99
+ const drainOwnedTasks = async (): Promise<void> => {
100
+ while (ownedTasks.size > 0) await Promise.allSettled([...ownedTasks]);
101
+ };
102
+
103
+ const clearUi = (ctx: ExtensionContext): void => {
104
+ try {
105
+ ctx.ui.setWidget(CHAT_UI_KEY, undefined);
106
+ ctx.ui.setStatus(CHAT_UI_KEY, undefined);
107
+ } catch {
108
+ // Session replacement may invalidate an old UI immediately.
109
+ }
110
+ widgetRender = undefined;
111
+ widgetInstalled = false;
112
+ };
113
+
114
+ const updateUi = (ctx: ExtensionContext, snapshot?: ChatSnapshot): void => {
115
+ if (ctx.sessionManager !== activeSessionManager) return;
116
+ latestSnapshot = snapshot;
117
+ try {
118
+ ctx.ui.setStatus(
119
+ CHAT_UI_KEY,
120
+ snapshot?.state === "connecting"
121
+ ? restoringRoomId === snapshot.room.id
122
+ ? `chat: restoring ${sanitizeSingleLine(snapshot.room.label)}`
123
+ : "chat: joining"
124
+ : snapshot?.state === "degraded"
125
+ ? "chat: reconnecting"
126
+ : undefined,
127
+ );
128
+ const mode = settings.widgetMode ?? "count";
129
+ if (
130
+ ctx.mode !== "tui" ||
131
+ !snapshot ||
132
+ snapshot.state === "disconnected" ||
133
+ mode === "off"
134
+ ) {
135
+ ctx.ui.setWidget(CHAT_UI_KEY, undefined);
136
+ widgetInstalled = false;
137
+ widgetRender = undefined;
138
+ return;
139
+ }
140
+ if (!widgetInstalled) {
141
+ ctx.ui.setWidget(CHAT_UI_KEY, (tui, theme) => {
142
+ const requestRender = () => tui.requestRender();
143
+ widgetRender = requestRender;
144
+ return {
145
+ render: (width: number) =>
146
+ latestSnapshot
147
+ ? renderChatWidget(
148
+ latestSnapshot,
149
+ settings.widgetMode ?? "count",
150
+ width,
151
+ theme,
152
+ tui.terminal.rows,
153
+ )
154
+ : [],
155
+ invalidate() {},
156
+ dispose() {
157
+ if (widgetRender === requestRender) widgetRender = undefined;
158
+ },
159
+ };
160
+ });
161
+ widgetInstalled = true;
162
+ }
163
+ widgetRender?.();
164
+ } catch {
165
+ // UI updates are best-effort after replacement.
166
+ }
167
+ };
168
+
169
+ const disconnectRoom = async (): Promise<void> => {
170
+ const owned = chatSession;
171
+ chatSession = undefined;
172
+ latestSnapshot = undefined;
173
+ chatDraft = "";
174
+ if (owned) await owned.leave();
175
+ if (activeContext) clearUi(activeContext);
176
+ };
177
+
178
+ const ensureIdentity = async (
179
+ ctx: ExtensionContext,
180
+ signal: AbortSignal,
181
+ owner: unknown,
182
+ ownerGeneration: number,
183
+ ): Promise<ChatIdentity | undefined> => {
184
+ let nickname = settings.nickname;
185
+ if (!nickname) {
186
+ const entered = await ctx.ui.input(
187
+ "Choose a Pi Chat nickname",
188
+ "Visible to room peers; no OS or Git identity is used",
189
+ { signal },
190
+ );
191
+ if (!isCurrent(owner, ownerGeneration) || signal.aborted || !entered) return undefined;
192
+ nickname = entered;
193
+ }
194
+ let seed = settings.identitySeed;
195
+ let widgetMode = settings.widgetMode;
196
+ if (!seed) {
197
+ const candidate = createIdentity(deps.randomBytes(32));
198
+ if (!widgetMode) {
199
+ const selected = await ctx.ui.select(
200
+ "Joined room display",
201
+ DISPLAY_OPTIONS.map(({ label }) => label),
202
+ { signal },
203
+ );
204
+ if (!selected || !isCurrent(owner, ownerGeneration) || signal.aborted) return undefined;
205
+ widgetMode = DISPLAY_OPTIONS.find(({ label }) => label === selected)?.mode;
206
+ if (!widgetMode) return undefined;
207
+ }
208
+ const display =
209
+ DISPLAY_OPTIONS.find(({ mode }) => mode === widgetMode)?.label ?? widgetMode;
210
+ const confirmed = await ctx.ui.confirm(
211
+ "Create Pi Chat identity?",
212
+ `${formatIdentityLabel(nickname, candidate.publicKey)}\nDisplay: ${display}\nThis pseudonymous fingerprint is not real-world identity verification.`,
213
+ { signal },
214
+ );
215
+ if (!confirmed || !isCurrent(owner, ownerGeneration) || signal.aborted) return undefined;
216
+ seed = candidate.seed;
217
+ }
218
+ if (
219
+ nickname !== settings.nickname ||
220
+ seed !== settings.identitySeed ||
221
+ widgetMode !== settings.widgetMode
222
+ ) {
223
+ const updated = await updateChatSettings(
224
+ {
225
+ nickname,
226
+ identitySeed: seed,
227
+ ...(widgetMode ? { widgetMode } : {}),
228
+ },
229
+ { settingsPath: deps.settingsPath, signal },
230
+ );
231
+ if (!isCurrent(owner, ownerGeneration)) return undefined;
232
+ settings = updated;
233
+ }
234
+ return createIdentity(Buffer.from(seed, "base64url"));
235
+ };
236
+
237
+ const joinRoom = async (
238
+ room: RoomDescriptor,
239
+ ctx: ExtensionContext,
240
+ signal: AbortSignal,
241
+ options?: JoinRoomOptions,
242
+ ): Promise<boolean> => {
243
+ if (chatSession && latestSnapshot?.state !== "disconnected") {
244
+ throw new Error("Leave the current Pi Chat room before joining another.");
245
+ }
246
+ const owner = ctx.sessionManager;
247
+ const ownerGeneration = generation;
248
+ if (!isCurrent(owner, ownerGeneration)) throw new Error("Pi Chat session is stale.");
249
+ let remember = options?.remember ?? false;
250
+ if (room.kind === "private" && options === undefined) {
251
+ const selected = await ctx.ui.select(
252
+ "Private bearer invite — restore this room after restarting Pi?",
253
+ [...PRIVATE_ROOM_OPTIONS],
254
+ { signal },
255
+ );
256
+ if (
257
+ !selected ||
258
+ selected === PRIVATE_ROOM_OPTIONS[2] ||
259
+ !isCurrent(owner, ownerGeneration) ||
260
+ signal.aborted
261
+ ) {
262
+ return false;
263
+ }
264
+ remember = selected === PRIVATE_ROOM_OPTIONS[0];
265
+ }
266
+ const identity = await ensureIdentity(ctx, signal, owner, ownerGeneration);
267
+ if (!identity || !isCurrent(owner, ownerGeneration) || signal.aborted) return false;
268
+ const nickname = settings.nickname;
269
+ if (!nickname) throw new Error("Pi Chat nickname is unavailable.");
270
+ const transport = deps.createTransport({ room, identity, maxPeers: 16 });
271
+ const session = new ChatSession({
272
+ room,
273
+ identity,
274
+ nickname,
275
+ transport,
276
+ onChange: (snapshot) => {
277
+ if (chatSession !== session || !isCurrent(owner, ownerGeneration)) return;
278
+ updateUi(ctx, snapshot);
279
+ },
280
+ });
281
+ chatSession = session;
282
+ ctx.ui.setStatus(CHAT_UI_KEY, "chat: joining");
283
+ try {
284
+ await session.start(AbortSignal.any([signal, controller.signal]));
285
+ if (!isCurrent(owner, ownerGeneration) || chatSession !== session) {
286
+ await session.leave();
287
+ return false;
288
+ }
289
+ if (remember) {
290
+ const rememberedRoom = rememberedRoomFromDescriptor(room);
291
+ const next = await updateChatSettings(
292
+ {
293
+ resume: {
294
+ rooms: [rememberedRoom],
295
+ activeRoomId: rememberedRoom.id,
296
+ surface: "chat",
297
+ },
298
+ },
299
+ { settingsPath: deps.settingsPath, signal },
300
+ );
301
+ if (!isCurrent(owner, ownerGeneration) || chatSession !== session) {
302
+ await session.leave();
303
+ return false;
304
+ }
305
+ settings = next;
306
+ }
307
+ restoreError = undefined;
308
+ latestSnapshot = session.snapshot();
309
+ updateUi(ctx, latestSnapshot);
310
+ return true;
311
+ } catch (error) {
312
+ if (chatSession === session) chatSession = undefined;
313
+ await session.leave();
314
+ clearUi(ctx);
315
+ if (!signal.aborted && isCurrent(owner, ownerGeneration)) throw error;
316
+ return false;
317
+ }
318
+ };
319
+
320
+ const updateRememberedSurface = async (
321
+ surface: "chat" | "pi",
322
+ ctx: ExtensionContext,
323
+ owner: unknown,
324
+ ownerGeneration: number,
325
+ session: ChatSession,
326
+ ): Promise<void> => {
327
+ const resume = settings.resume;
328
+ if (
329
+ !resume ||
330
+ resume.activeRoomId !== session.snapshot().room.id ||
331
+ resume.surface === surface
332
+ ) {
333
+ return;
334
+ }
335
+ try {
336
+ const next = await updateChatSettings(
337
+ { resume: { ...resume, surface } },
338
+ { settingsPath: deps.settingsPath, signal: controller.signal },
339
+ );
340
+ if (isCurrent(owner, ownerGeneration) && chatSession === session) settings = next;
341
+ } catch (error) {
342
+ if (isCurrent(owner, ownerGeneration) && chatSession === session) {
343
+ notifySafely(
344
+ ctx,
345
+ `Pi Chat could not save the restart view: ${sanitizeSingleLine(error instanceof Error ? error.message : String(error))}.`,
346
+ "error",
347
+ );
348
+ }
349
+ }
350
+ };
351
+
352
+ const openChat = async (ctx: ExtensionContext): Promise<void> => {
353
+ const session = chatSession;
354
+ if (!session || session.snapshot().state === "disconnected") {
355
+ throw new Error("Join a Pi Chat room first.");
356
+ }
357
+ const owner = ctx.sessionManager;
358
+ const ownerGeneration = generation;
359
+ const ownerSignal = controller.signal;
360
+ await updateRememberedSurface("chat", ctx, owner, ownerGeneration, session);
361
+ if (!isCurrent(owner, ownerGeneration) || chatSession !== session) return;
362
+ await ctx.ui.custom<void>(
363
+ (tui, theme, _keybindings, done) =>
364
+ new ChatView({
365
+ tui,
366
+ theme,
367
+ getSnapshot: () => session.snapshot(),
368
+ send: (text) => session.send(text),
369
+ initialDraft: chatDraft,
370
+ onDraftChange: (text) => {
371
+ if (isCurrent(owner, ownerGeneration) && chatSession === session) chatDraft = text;
372
+ },
373
+ setViewOpen: (open) => session.setViewOpen(open),
374
+ subscribe: (listener) => session.subscribe(listener),
375
+ signal: ownerSignal,
376
+ onReturnToPi: () => {
377
+ void trackTask(updateRememberedSurface("pi", ctx, owner, ownerGeneration, session));
378
+ },
379
+ onClose: () => done(undefined),
380
+ }),
381
+ );
382
+ if (isCurrent(owner, ownerGeneration) && chatSession === session)
383
+ updateUi(ctx, session.snapshot());
384
+ };
385
+
386
+ const restoreRememberedRoom = async (
387
+ ctx: ExtensionContext,
388
+ ownerGeneration: number,
389
+ signal: AbortSignal = controller.signal,
390
+ ): Promise<void> => {
391
+ const resume = settings.resume;
392
+ if (!resume || !settings.nickname || !settings.identitySeed || ctx.mode !== "tui") return;
393
+ const remembered = resume.rooms.find(({ id }) => id === resume.activeRoomId);
394
+ if (!remembered || !isCurrent(ctx.sessionManager, ownerGeneration)) return;
395
+ let room: RoomDescriptor;
396
+ try {
397
+ room = descriptorFromRememberedRoom(remembered);
398
+ } catch {
399
+ notifySafely(ctx, "Pi Chat could not restore the saved room; fix pi-chat.json.", "error");
400
+ return;
401
+ }
402
+ restoreError = undefined;
403
+ restoringRoomId = room.id;
404
+ try {
405
+ ctx.ui.setStatus(CHAT_UI_KEY, `chat: restoring ${sanitizeSingleLine(room.label)}`);
406
+ const joined = await joinRoom(room, ctx, signal, { remember: false });
407
+ if (!joined || signal.aborted || !isCurrent(ctx.sessionManager, ownerGeneration)) return;
408
+ if (resume.surface === "chat") await openChat(ctx);
409
+ } catch (error) {
410
+ if (isCurrent(ctx.sessionManager, ownerGeneration)) {
411
+ restoreError = sanitizeSingleLine(error instanceof Error ? error.message : String(error));
412
+ ctx.ui.setStatus(CHAT_UI_KEY, "chat: restore failed");
413
+ notifySafely(
414
+ ctx,
415
+ `Pi Chat could not restore ${sanitizeSingleLine(room.label)}: ${restoreError}. Use /chat to retry or forget it.`,
416
+ "error",
417
+ );
418
+ }
419
+ } finally {
420
+ if (restoringRoomId === room.id) restoringRoomId = undefined;
421
+ }
422
+ };
423
+
424
+ const menuSource = (ctx: ExtensionCommandContext): ChatMenuSource => {
425
+ const resetIdentity = createIdentity(deps.randomBytes(32));
426
+ const owner = ctx.sessionManager;
427
+ const ownerGeneration = generation;
428
+ const ownsMenu = () => isCurrent(owner, ownerGeneration);
429
+ return {
430
+ settingsPath: deps.settingsPath,
431
+ getSettings: () => settings,
432
+ getSnapshot: () => chatSession?.snapshot(),
433
+ getRestoreError: () => restoreError,
434
+ createPrivateRoom: () => createPrivateRoom(deps.randomBytes(32)),
435
+ joinRoom,
436
+ openChat: async (commandCtx) => {
437
+ if (ownsMenu()) await openChat(commandCtx);
438
+ },
439
+ retryRememberedRoom: async (commandCtx, signal) => {
440
+ if (!ownsMenu() || signal.aborted) return;
441
+ await restoreRememberedRoom(
442
+ commandCtx,
443
+ ownerGeneration,
444
+ AbortSignal.any([signal, controller.signal]),
445
+ );
446
+ if (restoreError) throw new Error(restoreError);
447
+ },
448
+ forgetRememberedRoom: async (signal) => {
449
+ if (!ownsMenu()) return;
450
+ if (settings.resume) {
451
+ const next = await updateChatSettings(
452
+ { resume: null },
453
+ { settingsPath: deps.settingsPath, signal },
454
+ );
455
+ if (!ownsMenu()) return;
456
+ settings = next;
457
+ }
458
+ restoreError = undefined;
459
+ clearUi(ctx);
460
+ },
461
+ leaveRoom: async (signal) => {
462
+ if (!ownsMenu()) return;
463
+ const currentRoomId = chatSession?.snapshot().room.id;
464
+ if (settings.resume && settings.resume.activeRoomId === currentRoomId) {
465
+ const next = await updateChatSettings(
466
+ { resume: null },
467
+ { settingsPath: deps.settingsPath, signal },
468
+ );
469
+ if (!ownsMenu()) return;
470
+ settings = next;
471
+ }
472
+ restoreError = undefined;
473
+ await disconnectRoom();
474
+ },
475
+ toggleMute(publicKey) {
476
+ if (!ownsMenu() || !/^[0-9a-f]{64}$/u.test(publicKey)) return undefined;
477
+ const muted = chatSession?.toggleMute(Buffer.from(publicKey, "hex"));
478
+ if (chatSession) updateUi(ctx, chatSession.snapshot());
479
+ return muted;
480
+ },
481
+ async updateNickname(value, signal) {
482
+ const previous = settings;
483
+ const next = await updateChatSettings(
484
+ { nickname: value },
485
+ { settingsPath: deps.settingsPath, signal },
486
+ );
487
+ if (!ownsMenu()) return;
488
+ settings = next;
489
+ try {
490
+ chatSession?.updateNickname(value);
491
+ } catch (error) {
492
+ settings = previous;
493
+ throw error;
494
+ }
495
+ if (chatSession) updateUi(ctx, chatSession.snapshot());
496
+ },
497
+ async updateWidgetMode(value, signal) {
498
+ const next = await updateChatSettings(
499
+ { widgetMode: value },
500
+ { settingsPath: deps.settingsPath, signal },
501
+ );
502
+ if (!ownsMenu()) return;
503
+ settings = next;
504
+ updateUi(ctx, chatSession?.snapshot());
505
+ },
506
+ getIdentityResetPreview: () => {
507
+ const current = settings.identitySeed
508
+ ? formatIdentityLabel(
509
+ settings.nickname ?? "anonymous",
510
+ createIdentity(Buffer.from(settings.identitySeed, "base64url")).publicKey,
511
+ )
512
+ : "not created";
513
+ return {
514
+ current,
515
+ next: formatIdentityLabel(settings.nickname ?? "anonymous", resetIdentity.publicKey),
516
+ };
517
+ },
518
+ async resetIdentity(signal) {
519
+ const next = await updateChatSettings(
520
+ { identitySeed: resetIdentity.seed, resume: null },
521
+ { settingsPath: deps.settingsPath, signal },
522
+ );
523
+ if (!ownsMenu()) return;
524
+ settings = next;
525
+ await disconnectRoom();
526
+ },
527
+ };
528
+ };
529
+
530
+ pi.registerCommand("chat", {
531
+ description: "Open experimental peer-to-peer developer chat",
532
+ handler: async (args, ctx) => {
533
+ if (ctx.mode !== "tui") throw new Error("Pi Chat requires Pi TUI mode.");
534
+ const owner = ctx.sessionManager;
535
+ const ownerGeneration = generation;
536
+ if (!isCurrent(owner, ownerGeneration)) throw new Error("Pi Chat session is stale.");
537
+ const input = args.trim();
538
+ if (!input) {
539
+ await showChatMenu(ctx, menuSource(ctx), {
540
+ signal: controller.signal,
541
+ isCurrent: () => isCurrent(owner, ownerGeneration),
542
+ });
543
+ return;
544
+ }
545
+ if (/\s/u.test(input)) {
546
+ notifySafely(ctx, USAGE, "warning");
547
+ return;
548
+ }
549
+ let room: RoomDescriptor;
550
+ let openAfterJoin = false;
551
+ if (input.startsWith("pichat:")) {
552
+ openAfterJoin = true;
553
+ try {
554
+ room = parseInvite(input);
555
+ } catch {
556
+ notifySafely(ctx, USAGE, "warning");
557
+ return;
558
+ }
559
+ } else if (input.startsWith("#")) {
560
+ openAfterJoin = true;
561
+ try {
562
+ room = createPublicRoom(input.slice(1));
563
+ } catch {
564
+ notifySafely(ctx, USAGE, "warning");
565
+ return;
566
+ }
567
+ const confirmed = await ctx.ui.confirm(
568
+ "Join public room?",
569
+ "Anyone can join or record it. DHT and direct peers may observe network metadata.",
570
+ { signal: controller.signal },
571
+ );
572
+ if (!confirmed || !isCurrent(owner, ownerGeneration)) return;
573
+ } else {
574
+ notifySafely(ctx, USAGE, "warning");
575
+ return;
576
+ }
577
+ const joined = await joinRoom(
578
+ room,
579
+ ctx,
580
+ controller.signal,
581
+ room.kind === "public" ? { remember: true } : undefined,
582
+ );
583
+ if (
584
+ joined &&
585
+ openAfterJoin &&
586
+ !controller.signal.aborted &&
587
+ isCurrent(owner, ownerGeneration)
588
+ ) {
589
+ await openChat(ctx);
590
+ }
591
+ },
592
+ });
593
+
594
+ pi.on("session_start", async (_event, ctx) => {
595
+ controller.abort(new DOMException("Pi Chat session replaced", "AbortError"));
596
+ await disconnectRoom();
597
+ await drainOwnedTasks();
598
+ controller = new AbortController();
599
+ generation += 1;
600
+ activeSessionManager = ctx.sessionManager;
601
+ activeContext = ctx;
602
+ restoreError = undefined;
603
+ clearUi(ctx);
604
+ const ownerGeneration = generation;
605
+ const loaded = await readChatSettings(deps.settingsPath);
606
+ if (generation !== ownerGeneration || activeSessionManager !== ctx.sessionManager) return;
607
+ if (loaded.kind === "loaded") settings = loaded.settings;
608
+ else if (loaded.kind === "missing") settings = {};
609
+ else {
610
+ settings = {};
611
+ notifySafely(ctx, "Pi Chat settings are invalid; fix the file before saving.", "error");
612
+ }
613
+ if (ctx.hasUI) notifySafely(ctx, EXPERIMENTAL_WARNING, "warning");
614
+ if (settings.resume && ctx.mode === "tui") {
615
+ void trackTask(restoreRememberedRoom(ctx, ownerGeneration));
616
+ }
617
+ });
618
+
619
+ pi.on("session_shutdown", async (_event, ctx) => {
620
+ const owner = ctx.sessionManager;
621
+ if (owner !== activeSessionManager) return;
622
+ controller.abort(new DOMException("Pi Chat session shut down", "AbortError"));
623
+ const shutdownGeneration = ++generation;
624
+ await disconnectRoom();
625
+ await drainOwnedTasks();
626
+ await awaitChatSettingsWrites(deps.settingsPath);
627
+ if (activeSessionManager !== owner || generation !== shutdownGeneration) return;
628
+ clearUi(ctx);
629
+ activeSessionManager = undefined;
630
+ activeContext = undefined;
631
+ });
632
+ };
633
+ }
634
+
635
+ function notifySafely(
636
+ ctx: ExtensionContext,
637
+ message: string,
638
+ level: "info" | "warning" | "error",
639
+ ): void {
640
+ try {
641
+ ctx.ui.notify(sanitizeSingleLine(message), level);
642
+ } catch {
643
+ // Stale UI errors must not escape lifecycle cleanup.
644
+ }
645
+ }
646
+
647
+ export default createPiChatExtension();