@narumitw/pi-chat 0.0.0 → 0.1.1

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 CHANGED
@@ -6,16 +6,16 @@ import type {
6
6
  } from "@earendil-works/pi-coding-agent";
7
7
  import type { ChatSnapshot, ChatTransport } from "./chat-session.js";
8
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";
9
+ import type { PublicRoomDirectory } from "./directory-network.js";
13
10
  import {
14
- createPrivateRoom,
15
- createPublicRoom,
16
- parseInvite,
17
- type RoomDescriptor,
18
- } from "./protocol.js";
11
+ type ChatIdentity,
12
+ createIdentity,
13
+ deriveScopedIdentity,
14
+ formatIdentityLabel,
15
+ } from "./identity.js";
16
+ import type { ChatMenuSource, JoinRoomOptions } from "./menu.js";
17
+ import { type HyperswarmTransportOptions, MAX_DIRECT_NEIGHBORS } from "./network-contract.js";
18
+ import { createPrivateRoom, createPublicRoom, parseInvite, type RoomDescriptor } from "./room.js";
19
19
  import {
20
20
  awaitChatSettingsWrites,
21
21
  type ChatSettings,
@@ -27,12 +27,11 @@ import {
27
27
  type WidgetMode,
28
28
  } from "./settings.js";
29
29
  import { sanitizeSingleLine } from "./text.js";
30
- import { renderChatWidget } from "./widget.js";
31
30
 
32
31
  const CHAT_UI_KEY = "chat";
33
32
  const EXPERIMENTAL_WARNING =
34
33
  "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>";
34
+ const USAGE = "Usage: /chat, /chat <pichat:v1-or-v2:invite>, or /chat #<public-slug>";
36
35
  const PRIVATE_ROOM_OPTIONS = [
37
36
  "Join and remember — Save the bearer invite privately and restore this room",
38
37
  "Join once — Do not save the bearer invite",
@@ -48,22 +47,57 @@ const DISPLAY_OPTIONS: ReadonlyArray<{ label: string; mode: WidgetMode }> = [
48
47
  { label: "Hidden — Show no persistent room widget", mode: "off" },
49
48
  ];
50
49
 
50
+ export interface PiChatDirectoryOptions {
51
+ identity: ChatIdentity;
52
+ advertisedSlug?: string;
53
+ }
54
+
55
+ type Awaitable<Value> = Value | Promise<Value>;
56
+ type ChatMenuModule = Pick<typeof import("./menu.js"), "showChatMenu">;
57
+ type ChatViewModule = Pick<typeof import("./chat-view.js"), "ChatView">;
58
+ type ChatWidgetModule = Pick<typeof import("./widget.js"), "renderChatWidget">;
59
+
51
60
  export interface PiChatDependencies {
52
61
  settingsPath: string;
53
62
  randomBytes(size: number): Buffer;
54
- createTransport(options: HyperswarmTransportOptions): ChatTransport;
63
+ createTransport(options: HyperswarmTransportOptions): Awaitable<ChatTransport>;
64
+ createDirectory(options: PiChatDirectoryOptions): Awaitable<PublicRoomDirectory>;
55
65
  updateSettings: typeof updateChatSettingsFile;
66
+ loadChatMenu(): Promise<ChatMenuModule>;
67
+ loadChatView(): Promise<ChatViewModule>;
68
+ loadChatWidget(): Promise<ChatWidgetModule>;
56
69
  }
57
70
 
58
71
  export function createPiChatExtension(
59
72
  dependencies: Partial<PiChatDependencies> = {},
60
73
  ): (pi: ExtensionAPI) => void {
74
+ const loadNetwork = cachedModuleLoader(() => import("./network.js"));
75
+ const loadDirectoryNetwork = cachedModuleLoader(() => import("./directory-network.js"));
61
76
  const deps: PiChatDependencies = {
62
77
  settingsPath: dependencies.settingsPath ?? chatSettingsPath(),
63
78
  randomBytes: dependencies.randomBytes ?? nodeRandomBytes,
64
79
  createTransport:
65
- dependencies.createTransport ?? ((options) => new HyperswarmTransport(options)),
80
+ dependencies.createTransport ??
81
+ (async (options) => {
82
+ const { HyperswarmTransport } = await loadNetwork();
83
+ return new HyperswarmTransport(options);
84
+ }),
85
+ createDirectory:
86
+ dependencies.createDirectory ??
87
+ (async (options) => {
88
+ const { HyperswarmDirectoryTransport, PublicRoomDirectorySession } =
89
+ await loadDirectoryNetwork();
90
+ return new PublicRoomDirectorySession({
91
+ ...options,
92
+ transport: new HyperswarmDirectoryTransport({ identity: options.identity }),
93
+ });
94
+ }),
66
95
  updateSettings: dependencies.updateSettings ?? updateChatSettingsFile,
96
+ loadChatMenu: cachedModuleLoader(dependencies.loadChatMenu ?? (() => import("./menu.js"))),
97
+ loadChatView: cachedModuleLoader(dependencies.loadChatView ?? (() => import("./chat-view.js"))),
98
+ loadChatWidget: cachedModuleLoader(
99
+ dependencies.loadChatWidget ?? (() => import("./widget.js")),
100
+ ),
67
101
  };
68
102
  const updateChatSettings = deps.updateSettings;
69
103
 
@@ -74,11 +108,14 @@ export function createPiChatExtension(
74
108
  let activeContext: ExtensionContext | undefined;
75
109
  let settings: ChatSettings = {};
76
110
  let chatSession: ChatSession | undefined;
111
+ let roomDirectory: PublicRoomDirectory | undefined;
77
112
  let latestSnapshot: ChatSnapshot | undefined;
78
113
  let chatDraft = "";
79
114
  let restoreError: string | undefined;
80
115
  let restoringRoomId: string | undefined;
116
+ let joinOwner: { sessionManager: unknown; generation: number; token: symbol } | undefined;
81
117
  const ownedTasks = new Set<Promise<unknown>>();
118
+ let renderChatWidget: ChatWidgetModule["renderChatWidget"] | undefined;
82
119
  let widgetRender: (() => void) | undefined;
83
120
  let widgetInstalled = false;
84
121
 
@@ -100,13 +137,15 @@ export function createPiChatExtension(
100
137
  while (ownedTasks.size > 0) await Promise.allSettled([...ownedTasks]);
101
138
  };
102
139
 
103
- const clearUi = (ctx: ExtensionContext): void => {
140
+ const clearUi = (ctx: ExtensionContext, ownerGeneration = generation): void => {
104
141
  try {
105
142
  ctx.ui.setWidget(CHAT_UI_KEY, undefined);
106
143
  ctx.ui.setStatus(CHAT_UI_KEY, undefined);
107
144
  } catch {
108
145
  // Session replacement may invalidate an old UI immediately.
109
146
  }
147
+ if (ctx.sessionManager !== activeSessionManager || generation !== ownerGeneration) return;
148
+ renderChatWidget = undefined;
110
149
  widgetRender = undefined;
111
150
  widgetInstalled = false;
112
151
  };
@@ -137,6 +176,8 @@ export function createPiChatExtension(
137
176
  widgetRender = undefined;
138
177
  return;
139
178
  }
179
+ const renderWidget = renderChatWidget;
180
+ if (!renderWidget) return;
140
181
  if (!widgetInstalled) {
141
182
  ctx.ui.setWidget(CHAT_UI_KEY, (tui, theme) => {
142
183
  const requestRender = () => tui.requestRender();
@@ -144,7 +185,7 @@ export function createPiChatExtension(
144
185
  return {
145
186
  render: (width: number) =>
146
187
  latestSnapshot
147
- ? renderChatWidget(
188
+ ? renderWidget(
148
189
  latestSnapshot,
149
190
  settings.widgetMode ?? "count",
150
191
  width,
@@ -168,11 +209,15 @@ export function createPiChatExtension(
168
209
 
169
210
  const disconnectRoom = async (): Promise<void> => {
170
211
  const owned = chatSession;
212
+ const ownedDirectory = roomDirectory;
213
+ const uiContext = activeContext;
214
+ const uiGeneration = generation;
171
215
  chatSession = undefined;
216
+ roomDirectory = undefined;
172
217
  latestSnapshot = undefined;
173
218
  chatDraft = "";
174
- if (owned) await owned.leave();
175
- if (activeContext) clearUi(activeContext);
219
+ await Promise.allSettled([owned?.leave(), ownedDirectory?.stop()]);
220
+ if (uiContext) clearUi(uiContext, uiGeneration);
176
221
  };
177
222
 
178
223
  const ensureIdentity = async (
@@ -234,7 +279,57 @@ export function createPiChatExtension(
234
279
  return createIdentity(Buffer.from(seed, "base64url"));
235
280
  };
236
281
 
237
- const joinRoom = async (
282
+ const startPublicRoomDirectory = (
283
+ room: RoomDescriptor,
284
+ identity: ChatIdentity,
285
+ session: ChatSession,
286
+ ctx: ExtensionContext,
287
+ owner: unknown,
288
+ ownerGeneration: number,
289
+ ): void => {
290
+ if (room.kind !== "public" || !room.slug) return;
291
+ void trackTask(
292
+ (async () => {
293
+ let directory: PublicRoomDirectory | undefined;
294
+ try {
295
+ directory = await deps.createDirectory({
296
+ identity: deriveScopedIdentity(identity, `directory:#${room.slug}`),
297
+ advertisedSlug: room.slug,
298
+ });
299
+ if (
300
+ !isCurrent(owner, ownerGeneration) ||
301
+ controller.signal.aborted ||
302
+ chatSession !== session
303
+ ) {
304
+ await directory.stop();
305
+ return;
306
+ }
307
+ roomDirectory = directory;
308
+ await directory.start(controller.signal);
309
+ } catch (error) {
310
+ const ownsDirectory = !directory || roomDirectory === directory;
311
+ if (directory && roomDirectory === directory) roomDirectory = undefined;
312
+ if (directory) await Promise.allSettled([directory.stop()]);
313
+ if (
314
+ ownsDirectory &&
315
+ isCurrent(owner, ownerGeneration) &&
316
+ chatSession === session &&
317
+ session.snapshot().room.id === room.id
318
+ ) {
319
+ notifySafely(
320
+ ctx,
321
+ `Pi Chat public-room discovery is unavailable: ${sanitizeSingleLine(
322
+ error instanceof Error ? error.message : String(error),
323
+ )}. Chat remains connected.`,
324
+ "warning",
325
+ );
326
+ }
327
+ }
328
+ })(),
329
+ );
330
+ };
331
+
332
+ const joinRoomOwned = async (
238
333
  room: RoomDescriptor,
239
334
  ctx: ExtensionContext,
240
335
  signal: AbortSignal,
@@ -267,7 +362,27 @@ export function createPiChatExtension(
267
362
  if (!identity || !isCurrent(owner, ownerGeneration) || signal.aborted) return false;
268
363
  const nickname = settings.nickname;
269
364
  if (!nickname) throw new Error("Pi Chat nickname is unavailable.");
270
- const transport = deps.createTransport({ room, identity, maxPeers: 16 });
365
+ const widgetModule = await loadOwnedModule(
366
+ deps.loadChatWidget,
367
+ () => isCurrent(owner, ownerGeneration) && !signal.aborted,
368
+ );
369
+ if (!widgetModule) return false;
370
+ let transport: ChatTransport;
371
+ try {
372
+ transport = await deps.createTransport({
373
+ room,
374
+ identity,
375
+ maxPeers: MAX_DIRECT_NEIGHBORS,
376
+ });
377
+ } catch (error) {
378
+ if (!isCurrent(owner, ownerGeneration) || signal.aborted) return false;
379
+ throw error;
380
+ }
381
+ if (!isCurrent(owner, ownerGeneration) || signal.aborted) {
382
+ await transport.stop();
383
+ return false;
384
+ }
385
+ renderChatWidget = widgetModule.renderChatWidget;
271
386
  const session = new ChatSession({
272
387
  room,
273
388
  identity,
@@ -307,16 +422,31 @@ export function createPiChatExtension(
307
422
  restoreError = undefined;
308
423
  latestSnapshot = session.snapshot();
309
424
  updateUi(ctx, latestSnapshot);
425
+ startPublicRoomDirectory(room, identity, session, ctx, owner, ownerGeneration);
310
426
  return true;
311
427
  } catch (error) {
312
428
  if (chatSession === session) chatSession = undefined;
313
429
  await session.leave();
314
- clearUi(ctx);
430
+ clearUi(ctx, ownerGeneration);
315
431
  if (!signal.aborted && isCurrent(owner, ownerGeneration)) throw error;
316
432
  return false;
317
433
  }
318
434
  };
319
435
 
436
+ const joinRoom: typeof joinRoomOwned = async (room, ctx, signal, options) => {
437
+ const existing = joinOwner;
438
+ if (existing?.sessionManager === ctx.sessionManager && existing.generation === generation) {
439
+ throw new Error("A Pi Chat room join is already in progress.");
440
+ }
441
+ const token = Symbol("chat-join");
442
+ joinOwner = { sessionManager: ctx.sessionManager, generation, token };
443
+ try {
444
+ return await joinRoomOwned(room, ctx, signal, options);
445
+ } finally {
446
+ if (joinOwner?.token === token) joinOwner = undefined;
447
+ }
448
+ };
449
+
320
450
  const updateRememberedSurface = async (
321
451
  surface: "chat" | "pi",
322
452
  ctx: ExtensionContext,
@@ -359,6 +489,12 @@ export function createPiChatExtension(
359
489
  const ownerSignal = controller.signal;
360
490
  await updateRememberedSurface("chat", ctx, owner, ownerGeneration, session);
361
491
  if (!isCurrent(owner, ownerGeneration) || chatSession !== session) return;
492
+ const viewModule = await loadOwnedModule(
493
+ deps.loadChatView,
494
+ () => isCurrent(owner, ownerGeneration) && chatSession === session,
495
+ );
496
+ if (!viewModule) return;
497
+ const { ChatView } = viewModule;
362
498
  await ctx.ui.custom<void>(
363
499
  (tui, theme, _keybindings, done) =>
364
500
  new ChatView({
@@ -432,6 +568,28 @@ export function createPiChatExtension(
432
568
  getSnapshot: () => chatSession?.snapshot(),
433
569
  getRestoreError: () => restoreError,
434
570
  createPrivateRoom: () => createPrivateRoom(deps.randomBytes(32)),
571
+ browsePublicRooms: async (signal) => {
572
+ if (!ownsMenu()) throw new Error("Pi Chat session is stale.");
573
+ const activeDirectory = roomDirectory;
574
+ const directory =
575
+ activeDirectory ??
576
+ (await deps.createDirectory({ identity: createIdentity(deps.randomBytes(32)) }));
577
+ const temporary = activeDirectory ? undefined : directory;
578
+ const browseSignal = AbortSignal.any([signal, controller.signal]);
579
+ if (!ownsMenu() || browseSignal.aborted) {
580
+ if (temporary) await temporary.stop();
581
+ throw browseSignal.reason ?? new DOMException("Aborted", "AbortError");
582
+ }
583
+ try {
584
+ const result = await directory.browse(browseSignal);
585
+ if (!ownsMenu() || browseSignal.aborted) {
586
+ throw browseSignal.reason ?? new DOMException("Aborted", "AbortError");
587
+ }
588
+ return result;
589
+ } finally {
590
+ if (temporary) await temporary.stop();
591
+ }
592
+ },
435
593
  joinRoom,
436
594
  openChat: async (commandCtx) => {
437
595
  if (ownsMenu()) await openChat(commandCtx);
@@ -536,6 +694,11 @@ export function createPiChatExtension(
536
694
  if (!isCurrent(owner, ownerGeneration)) throw new Error("Pi Chat session is stale.");
537
695
  const input = args.trim();
538
696
  if (!input) {
697
+ const menuModule = await loadOwnedModule(deps.loadChatMenu, () =>
698
+ isCurrent(owner, ownerGeneration),
699
+ );
700
+ if (!menuModule) return;
701
+ const { showChatMenu } = menuModule;
539
702
  await showChatMenu(ctx, menuSource(ctx), {
540
703
  signal: controller.signal,
541
704
  isCurrent: () => isCurrent(owner, ownerGeneration),
@@ -644,4 +807,30 @@ function notifySafely(
644
807
  }
645
808
  }
646
809
 
810
+ async function loadOwnedModule<Module>(
811
+ load: () => Promise<Module>,
812
+ isCurrent: () => boolean,
813
+ ): Promise<Module | undefined> {
814
+ try {
815
+ const module = await load();
816
+ return isCurrent() ? module : undefined;
817
+ } catch (error) {
818
+ if (!isCurrent()) return undefined;
819
+ throw error;
820
+ }
821
+ }
822
+
823
+ function cachedModuleLoader<Module>(load: () => Promise<Module>): () => Promise<Module> {
824
+ let pending: Promise<Module> | undefined;
825
+ return () => {
826
+ if (!pending) {
827
+ pending = load().catch((error) => {
828
+ pending = undefined;
829
+ throw error;
830
+ });
831
+ }
832
+ return pending;
833
+ };
834
+ }
835
+
647
836
  export default createPiChatExtension();