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