@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/README.md +67 -35
- package/package.json +3 -2
- package/src/chat-session.ts +325 -104
- package/src/chat-view.ts +14 -14
- package/src/directory-network.ts +416 -0
- package/src/external.d.ts +14 -0
- package/src/identity.ts +62 -14
- package/src/menu.ts +120 -30
- package/src/network-contract.ts +12 -0
- package/src/network.ts +18 -30
- package/src/nickname.ts +11 -0
- package/src/pi-chat.ts +209 -20
- package/src/protocol.ts +229 -124
- package/src/public-room-directory.ts +386 -0
- package/src/room.ts +88 -0
- package/src/settings.ts +22 -10
- package/src/widget.ts +7 -8
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 {
|
|
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
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
} from "./
|
|
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 ??
|
|
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
|
-
?
|
|
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
|
-
|
|
175
|
-
if (
|
|
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
|
|
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
|
|
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();
|