@narumitw/pi-chat 0.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,69 @@
1
+ declare module "hyperdht" {
2
+ export interface HyperDhtKeyPair {
3
+ publicKey: Buffer;
4
+ secretKey: Buffer;
5
+ }
6
+
7
+ interface HyperDhtConstructor {
8
+ keyPair(seed?: Uint8Array): HyperDhtKeyPair;
9
+ }
10
+
11
+ const HyperDHT: HyperDhtConstructor;
12
+ export default HyperDHT;
13
+ }
14
+
15
+ declare module "hyperswarm" {
16
+ import type { Duplex } from "node:stream";
17
+ import type { HyperDhtKeyPair } from "hyperdht";
18
+
19
+ export interface PeerInfo {
20
+ publicKey: Buffer;
21
+ topics: Buffer[];
22
+ ban(value?: boolean): void;
23
+ }
24
+
25
+ export interface PeerDiscovery {
26
+ flushed(): Promise<void>;
27
+ destroy(): Promise<void>;
28
+ refresh(options?: { client?: boolean; server?: boolean; limit?: number }): Promise<void>;
29
+ }
30
+
31
+ export interface HyperswarmOptions {
32
+ keyPair?: HyperDhtKeyPair;
33
+ seed?: Uint8Array;
34
+ maxPeers?: number;
35
+ firewall?: (remotePublicKey: Buffer) => boolean;
36
+ dht?: unknown;
37
+ bootstrap?: unknown[];
38
+ }
39
+
40
+ export default class Hyperswarm {
41
+ constructor(options?: HyperswarmOptions);
42
+ connections: Set<Duplex>;
43
+ connecting: number;
44
+ on(event: "connection", listener: (socket: Duplex, info: PeerInfo) => void): this;
45
+ on(event: "update", listener: () => void): this;
46
+ on(event: "error", listener: (error: Error) => void): this;
47
+ join(
48
+ topic: Buffer,
49
+ options?: { client?: boolean; server?: boolean; limit?: number },
50
+ ): PeerDiscovery;
51
+ joinPeer(publicKey: Buffer): void;
52
+ leavePeer(publicKey: Buffer): void;
53
+ flush(): Promise<void>;
54
+ destroy(options?: { force?: boolean }): Promise<void>;
55
+ }
56
+ }
57
+
58
+ declare module "hyperdht/testnet.js" {
59
+ interface Testnet {
60
+ nodes: unknown[];
61
+ bootstrap: unknown[];
62
+ createNode(options?: Record<string, unknown>): unknown;
63
+ destroy(): Promise<void>;
64
+ }
65
+ export default function createTestnet(
66
+ size?: number,
67
+ options?: Record<string, unknown>,
68
+ ): Promise<Testnet>;
69
+ }
@@ -0,0 +1,80 @@
1
+ import { createHash } from "node:crypto";
2
+ import HyperDHT from "hyperdht";
3
+
4
+ const CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
5
+ const MAX_NICKNAME_GRAPHEMES = 24;
6
+ const BIDI_CONTROLS = /[\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/u;
7
+
8
+ export interface ChatIdentity {
9
+ seed: string;
10
+ publicKey: Buffer;
11
+ secretKey: Buffer;
12
+ tag: string;
13
+ }
14
+
15
+ export function normalizeNickname(value: unknown): string | undefined {
16
+ if (typeof value !== "string") return undefined;
17
+ const normalized = value.normalize("NFKC").trim();
18
+ if (!normalized || /\p{Cc}/u.test(normalized) || BIDI_CONTROLS.test(normalized)) return undefined;
19
+ const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
20
+ if (Array.from(segmenter.segment(normalized)).length > MAX_NICKNAME_GRAPHEMES) return undefined;
21
+ return normalized;
22
+ }
23
+
24
+ export function createIdentity(seed: Uint8Array): ChatIdentity {
25
+ if (seed.byteLength !== 32) throw new Error("Pi Chat identity seed must be exactly 32-byte.");
26
+ const stableSeed = Buffer.from(seed);
27
+ const keyPair = HyperDHT.keyPair(stableSeed);
28
+ return {
29
+ seed: stableSeed.toString("base64url"),
30
+ publicKey: Buffer.from(keyPair.publicKey),
31
+ secretKey: Buffer.from(keyPair.secretKey),
32
+ tag: identityTag(keyPair.publicKey),
33
+ };
34
+ }
35
+
36
+ export function identityTag(publicKey: Uint8Array, characters = 12): string {
37
+ if (characters < 12 || characters > 52) throw new Error("Identity tags use 12 to 52 characters.");
38
+ const digest = createHash("sha256").update(publicKey).digest();
39
+ let bits = 0;
40
+ let bitCount = 0;
41
+ let raw = "";
42
+ for (const byte of digest) {
43
+ bits = (bits << 8) | byte;
44
+ bitCount += 8;
45
+ while (bitCount >= 5 && raw.length < characters) {
46
+ bitCount -= 5;
47
+ raw += CROCKFORD[(bits >>> bitCount) & 31];
48
+ bits &= (1 << bitCount) - 1;
49
+ }
50
+ if (raw.length === characters) break;
51
+ }
52
+ return raw.match(/.{1,4}/gu)?.join("-") ?? raw;
53
+ }
54
+
55
+ export function formatIdentityLabel(
56
+ nickname: string,
57
+ publicKey: Uint8Array,
58
+ characters = 12,
59
+ ): string {
60
+ return `${nickname}~${identityTag(publicKey, characters)}`;
61
+ }
62
+
63
+ export function uniqueIdentityTags(publicKeys: readonly Uint8Array[]): Map<string, string> {
64
+ const fullKeys = publicKeys.map((key) => Buffer.from(key).toString("hex"));
65
+ const result = new Map<string, string>();
66
+ for (let length = 12; length <= 52; length += 4) {
67
+ const grouped = new Map<string, string[]>();
68
+ for (const [index, publicKey] of publicKeys.entries()) {
69
+ const tag = identityTag(publicKey, length);
70
+ const fullKey = fullKeys[index] ?? Buffer.from(publicKey).toString("hex");
71
+ grouped.set(tag, [...(grouped.get(tag) ?? []), fullKey]);
72
+ }
73
+ for (const [tag, keys] of grouped) {
74
+ const onlyKey = keys.length === 1 ? keys[0] : undefined;
75
+ if (onlyKey && !result.has(onlyKey)) result.set(onlyKey, tag);
76
+ }
77
+ if (result.size === publicKeys.length) break;
78
+ }
79
+ return result;
80
+ }
package/src/index.ts ADDED
@@ -0,0 +1 @@
1
+ export { default } from "./pi-chat.js";
package/src/menu.ts ADDED
@@ -0,0 +1,490 @@
1
+ import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
2
+ import type { MenuDefinition } from "@narumitw/pi-tui-kit";
3
+ import type { ChatSnapshot } from "./chat-session.js";
4
+ import { normalizeNickname } from "./identity.js";
5
+ import { createPublicRoom, parseInvite, type RoomDescriptor } from "./protocol.js";
6
+ import { type ChatSettings, descriptorFromRememberedRoom, type WidgetMode } from "./settings.js";
7
+ import { sanitizeSingleLine } from "./text.js";
8
+
9
+ export interface JoinRoomOptions {
10
+ remember: boolean;
11
+ }
12
+
13
+ export interface ChatMenuSource {
14
+ settingsPath: string;
15
+ getSettings(): ChatSettings;
16
+ getSnapshot(): ChatSnapshot | undefined;
17
+ getRestoreError(): string | undefined;
18
+ createPrivateRoom(): RoomDescriptor;
19
+ joinRoom(
20
+ room: RoomDescriptor,
21
+ ctx: ExtensionCommandContext,
22
+ signal: AbortSignal,
23
+ options?: JoinRoomOptions,
24
+ ): Promise<boolean>;
25
+ openChat(ctx: ExtensionCommandContext): Promise<void>;
26
+ retryRememberedRoom(ctx: ExtensionCommandContext, signal: AbortSignal): Promise<void>;
27
+ forgetRememberedRoom(signal: AbortSignal): Promise<void>;
28
+ leaveRoom(signal: AbortSignal): Promise<void>;
29
+ toggleMute(publicKey: string): boolean | undefined;
30
+ updateNickname(value: string, signal: AbortSignal): Promise<void>;
31
+ updateWidgetMode(value: WidgetMode, signal: AbortSignal): Promise<void>;
32
+ getIdentityResetPreview(): { current: string; next: string };
33
+ resetIdentity(signal: AbortSignal): Promise<void>;
34
+ }
35
+
36
+ interface ChatMenuState {
37
+ settings: ChatSettings;
38
+ snapshot?: ChatSnapshot;
39
+ pendingRoom?: RoomDescriptor;
40
+ restoreError?: string;
41
+ }
42
+
43
+ type Screen =
44
+ | "main"
45
+ | "invite"
46
+ | "joinInvite"
47
+ | "joinPublic"
48
+ | "joinAnother"
49
+ | "participants"
50
+ | "settings"
51
+ | "changeNickname"
52
+ | "widget"
53
+ | "resetIdentity"
54
+ | "leave"
55
+ | "forget"
56
+ | "status"
57
+ | "help";
58
+ type Action =
59
+ | "createPrivate"
60
+ | "joinPending"
61
+ | "joinInvite"
62
+ | "joinPublic"
63
+ | "retry"
64
+ | "forget"
65
+ | "open"
66
+ | "leave"
67
+ | "toggleMute"
68
+ | "changeNickname"
69
+ | "setWidget"
70
+ | "resetIdentity";
71
+
72
+ export function createChatMenu(source: ChatMenuSource) {
73
+ let pendingRoom: RoomDescriptor | undefined;
74
+ const getState = async (): Promise<ChatMenuState> => ({
75
+ settings: source.getSettings(),
76
+ snapshot: source.getSnapshot(),
77
+ pendingRoom,
78
+ ...(source.getRestoreError() ? { restoreError: source.getRestoreError() } : {}),
79
+ });
80
+ const menu: MenuDefinition<ChatMenuState, Screen, Action> = {
81
+ start: "main",
82
+ screens: {
83
+ main: ({ state }) => mainScreen(state),
84
+ invite: ({ state }) => {
85
+ const room = state.pendingRoom ?? state.snapshot?.room;
86
+ return {
87
+ kind: "review",
88
+ title: "Private room invite",
89
+ lines: [
90
+ "Anyone with this bearer invite can join.",
91
+ "After confirmation, choose whether to save it privately for restart restore.",
92
+ ],
93
+ content: room?.invite ?? "Invite is unavailable.",
94
+ format: { kind: "text" },
95
+ viewportSize: "adaptive",
96
+ ...(state.pendingRoom
97
+ ? {
98
+ confirm: {
99
+ id: "join-private",
100
+ label: "Join private room",
101
+ action: "joinPending" as const,
102
+ },
103
+ }
104
+ : {}),
105
+ hint: "back",
106
+ };
107
+ },
108
+ joinInvite: () => ({
109
+ kind: "input",
110
+ title: "Join with invite",
111
+ lines: [
112
+ "Paste a pichat:v1 invite. It grants access to the private room.",
113
+ "You will choose Join and remember, Join once, or Cancel before networking starts.",
114
+ ],
115
+ placeholder: "pichat:v1:…",
116
+ action: "joinInvite",
117
+ hint: "back",
118
+ }),
119
+ joinPublic: () => ({
120
+ kind: "input",
121
+ title: "Join public room",
122
+ lines: ["Use a lowercase room slug. Public rooms are guessable and open to anyone."],
123
+ placeholder: "pi-dev",
124
+ action: "joinPublic",
125
+ hint: "back",
126
+ }),
127
+ joinAnother: () => ({
128
+ kind: "actions",
129
+ title: "Join another room",
130
+ lines: ["A successfully remembered join replaces the room restored at startup."],
131
+ items: [
132
+ { id: "public", label: "Join public room", to: "joinPublic" },
133
+ { id: "invite", label: "Join with invite", to: "joinInvite" },
134
+ { id: "create", label: "Create private room", action: "createPrivate" },
135
+ ],
136
+ hint: "back",
137
+ }),
138
+ participants: ({ state }) => ({
139
+ kind: "choice",
140
+ title: "Direct participants",
141
+ lines: state.snapshot?.peers.length
142
+ ? ["Select a peer to toggle local mute. Full public keys are shown in details."]
143
+ : ["No authenticated direct peers are connected."],
144
+ items:
145
+ state.snapshot?.peers.map((peer) => ({
146
+ id: peer.publicKey,
147
+ label: sanitizeSingleLine(peer.label),
148
+ description: peer.muted ? "Muted locally" : "Receiving messages",
149
+ details: [peer.publicKey],
150
+ })) ?? [],
151
+ action: "toggleMute",
152
+ viewportSize: 10,
153
+ hint: "back",
154
+ }),
155
+ settings: ({ state }) => ({
156
+ kind: "actions",
157
+ title: "Pi Chat settings",
158
+ lines: [
159
+ `Nickname: ${sanitizeSingleLine(state.settings.nickname ?? "not set")}`,
160
+ `Joined room display: ${state.settings.widgetMode ?? "count"}`,
161
+ `Restart: ${restartDescription(state.settings)}`,
162
+ `User settings · ${sanitizeSingleLine(source.settingsPath)}`,
163
+ ],
164
+ items: [
165
+ { id: "nickname", label: "Change nickname", to: "changeNickname" },
166
+ { id: "widget", label: "Joined room display", to: "widget" },
167
+ { id: "reset", label: "Reset identity…", to: "resetIdentity" },
168
+ ],
169
+ hint: "back",
170
+ }),
171
+ changeNickname: () => ({
172
+ kind: "input",
173
+ title: "Change nickname",
174
+ lines: ["The immutable fingerprint remains attached to the new nickname."],
175
+ placeholder: "Mika",
176
+ action: "changeNickname",
177
+ hint: "back",
178
+ }),
179
+ widget: ({ state }) => ({
180
+ kind: "choice",
181
+ title: "Joined room display",
182
+ lines: ["Choose how much room content remains visible above the Pi editor."],
183
+ items: [
184
+ {
185
+ id: "dock",
186
+ label: "Room dock",
187
+ description: "Status, input target, and up to three recent messages",
188
+ },
189
+ { id: "latest", label: "Latest message", description: "Show one recent message" },
190
+ { id: "count", label: "Status only", description: "Hide message text" },
191
+ { id: "off", label: "Hidden", description: "Show no persistent room widget" },
192
+ ],
193
+ action: "setWidget",
194
+ currentItemId: state.settings.widgetMode ?? "count",
195
+ initialItemId: state.settings.widgetMode ?? "count",
196
+ hint: "back",
197
+ }),
198
+ resetIdentity: () => {
199
+ const preview = source.getIdentityResetPreview();
200
+ return {
201
+ kind: "review",
202
+ title: "Reset Pi Chat identity?",
203
+ lines: [
204
+ `Current: ${preview.current}`,
205
+ `New: ${preview.next}`,
206
+ "Resetting changes your fingerprint, forgets startup restore, and leaves the room.",
207
+ ],
208
+ content: "This cannot restore trust or blocked state associated with the old public key.",
209
+ format: { kind: "text" },
210
+ confirm: { id: "reset", label: "Reset identity", action: "resetIdentity" },
211
+ hint: "back",
212
+ };
213
+ },
214
+ leave: ({ state }) => {
215
+ const forgetsCurrent = state.settings.resume?.activeRoomId === state.snapshot?.room.id;
216
+ return {
217
+ kind: "review",
218
+ title: forgetsCurrent ? "Leave and forget room?" : "Leave room?",
219
+ lines: [
220
+ `Room: ${sanitizeSingleLine(state.snapshot?.room.label ?? "unknown")}`,
221
+ forgetsCurrent
222
+ ? "Leaving disconnects peers, clears this transcript, and disables startup restore."
223
+ : "Leaving disconnects peers and clears this ephemeral transcript.",
224
+ ],
225
+ content: "Messages already received by other peers cannot be withdrawn.",
226
+ format: { kind: "text" },
227
+ confirm: {
228
+ id: "leave",
229
+ label: forgetsCurrent ? "Leave and forget room" : "Leave room",
230
+ action: "leave",
231
+ },
232
+ hint: "back",
233
+ };
234
+ },
235
+ forget: ({ state }) => {
236
+ const room = rememberedRoom(state.settings);
237
+ return {
238
+ kind: "review",
239
+ title: "Forget saved room?",
240
+ lines: [
241
+ `Room: ${sanitizeSingleLine(room?.label ?? "unknown")}`,
242
+ "Pi Chat will not reconnect to this room at startup.",
243
+ ],
244
+ content: "This does not withdraw messages already received by peers.",
245
+ format: { kind: "text" },
246
+ confirm: { id: "forget", label: "Forget saved room", action: "forget" },
247
+ hint: "back",
248
+ };
249
+ },
250
+ status: ({ state }) => ({
251
+ kind: "detail",
252
+ title: "Pi Chat status",
253
+ lines: state.snapshot
254
+ ? [
255
+ `State: ${state.snapshot.state}`,
256
+ `Room: ${sanitizeSingleLine(state.snapshot.room.label)}`,
257
+ `Identity: ${sanitizeSingleLine(state.snapshot.localLabel)}`,
258
+ `Direct peers: ${state.snapshot.peers.length}`,
259
+ `Unread: ${state.snapshot.unread}`,
260
+ `Restart: ${restartDescription(state.settings)}`,
261
+ ...(state.snapshot.lastError
262
+ ? [`Attention: ${sanitizeSingleLine(state.snapshot.lastError)}`]
263
+ : []),
264
+ ]
265
+ : [
266
+ "State: disconnected",
267
+ `Restart: ${restartDescription(state.settings)}`,
268
+ ...(state.restoreError
269
+ ? [`Attention: ${sanitizeSingleLine(state.restoreError)}`]
270
+ : []),
271
+ `Settings: ${sanitizeSingleLine(source.settingsPath)}`,
272
+ ],
273
+ hint: "back",
274
+ }),
275
+ help: () => ({
276
+ kind: "detail",
277
+ title: "Pi Chat help",
278
+ lines: [
279
+ "Pi Chat is experimental and TUI-only.",
280
+ "Chat stays outside Pi sessions, prompts, model context, and repository files.",
281
+ "Private invites are bearer secrets. Public rooms are guessable.",
282
+ "Noise encrypts direct streams, but peers and DHT infrastructure may observe network metadata.",
283
+ "There is no offline delivery, authoritative room count, or message withdrawal.",
284
+ ],
285
+ hint: "back",
286
+ }),
287
+ },
288
+ actions: {
289
+ createPrivate: () => {
290
+ pendingRoom = source.createPrivateRoom();
291
+ return { kind: "to", screen: "invite" };
292
+ },
293
+ joinPending: async ({ ctx, signal }) => {
294
+ if (!pendingRoom) return { kind: "rejected", error: new Error("Invite is unavailable") };
295
+ if (!(await source.joinRoom(pendingRoom, ctx, signal)) || signal.aborted) {
296
+ return { kind: "stay" };
297
+ }
298
+ await source.openChat(ctx);
299
+ return { kind: "close" };
300
+ },
301
+ joinInvite: async ({ ctx, signal, value }) => {
302
+ let room: RoomDescriptor;
303
+ try {
304
+ room = parseInvite(value ?? "");
305
+ } catch (error) {
306
+ return { kind: "rejected", error };
307
+ }
308
+ if (!(await source.joinRoom(room, ctx, signal)) || signal.aborted) return { kind: "stay" };
309
+ await source.openChat(ctx);
310
+ return { kind: "close" };
311
+ },
312
+ joinPublic: async ({ ctx, signal, value }) => {
313
+ let room: RoomDescriptor;
314
+ try {
315
+ room = createPublicRoom((value ?? "").replace(/^#/u, ""));
316
+ } catch (error) {
317
+ return { kind: "rejected", error };
318
+ }
319
+ const confirmed = await ctx.ui.confirm(
320
+ "Join public room?",
321
+ "Anyone can join or record it. DHT and direct peers may observe network metadata.",
322
+ { signal },
323
+ );
324
+ if (!confirmed || signal.aborted) return { kind: "stay" };
325
+ if (!(await source.joinRoom(room, ctx, signal, { remember: true })) || signal.aborted) {
326
+ return { kind: "stay" };
327
+ }
328
+ await source.openChat(ctx);
329
+ return { kind: "close" };
330
+ },
331
+ retry: async ({ ctx, signal }) => {
332
+ await source.retryRememberedRoom(ctx, signal);
333
+ return { kind: "close" };
334
+ },
335
+ forget: async ({ signal }) => {
336
+ await source.forgetRememberedRoom(signal);
337
+ return { kind: "to", screen: "main" };
338
+ },
339
+ open: async ({ ctx }) => {
340
+ await source.openChat(ctx);
341
+ return { kind: "close" };
342
+ },
343
+ leave: async ({ signal }) => {
344
+ await source.leaveRoom(signal);
345
+ return { kind: "to", screen: "main" };
346
+ },
347
+ toggleMute: ({ itemId }) => {
348
+ const muted = source.toggleMute(itemId);
349
+ return muted === undefined
350
+ ? { kind: "rejected", error: new Error("Peer is no longer connected") }
351
+ : { kind: "to", screen: "participants" };
352
+ },
353
+ changeNickname: async ({ signal, value }) => {
354
+ const nickname = normalizeNickname(value);
355
+ if (!nickname) return { kind: "rejected", error: new Error("Nickname is invalid") };
356
+ await source.updateNickname(nickname, signal);
357
+ return { kind: "to", screen: "settings" };
358
+ },
359
+ setWidget: async ({ signal, itemId }) => {
360
+ if (itemId !== "dock" && itemId !== "count" && itemId !== "latest" && itemId !== "off") {
361
+ return { kind: "rejected", error: new Error("Widget mode is invalid") };
362
+ }
363
+ await source.updateWidgetMode(itemId, signal);
364
+ return { kind: "to", screen: "settings" };
365
+ },
366
+ resetIdentity: async ({ signal }) => {
367
+ await source.resetIdentity(signal);
368
+ return { kind: "to", screen: "settings" };
369
+ },
370
+ },
371
+ };
372
+ return { menu, getState };
373
+ }
374
+
375
+ export async function showChatMenu(
376
+ ctx: ExtensionCommandContext,
377
+ source: ChatMenuSource,
378
+ ownership: { signal: AbortSignal; isCurrent: () => boolean },
379
+ ): Promise<void> {
380
+ const { runMenu } = await import("@narumitw/pi-tui-kit");
381
+ if (ownership.signal.aborted || !ownership.isCurrent()) return;
382
+ const controller = createChatMenu(source);
383
+ await runMenu(ctx, controller.menu, {
384
+ getState: controller.getState,
385
+ signal: ownership.signal,
386
+ isCurrent: ownership.isCurrent,
387
+ onError: (_ctx, error) => {
388
+ if (ownership.isCurrent() && !ownership.signal.aborted) {
389
+ ctx.ui.notify(`Pi Chat failed: ${sanitizeSingleLine(safeError(error))}`, "error");
390
+ }
391
+ },
392
+ });
393
+ }
394
+
395
+ function mainScreen(state: ChatMenuState) {
396
+ const remembered = rememberedRoom(state.settings);
397
+ if (!state.snapshot || state.snapshot.state === "disconnected") {
398
+ if (remembered) {
399
+ return {
400
+ kind: "actions" as const,
401
+ title: state.restoreError
402
+ ? `Pi Chat · could not restore ${sanitizeSingleLine(remembered.label)}`
403
+ : `Pi Chat · ${sanitizeSingleLine(remembered.label)} remembered`,
404
+ lines: [
405
+ state.restoreError
406
+ ? `Attention: ${sanitizeSingleLine(state.restoreError)}`
407
+ : "Disconnected. This room is configured to reconnect at startup.",
408
+ `Restart surface: ${state.settings.resume?.surface === "chat" ? "open chat" : "Pi/LLM"}`,
409
+ ],
410
+ items: [
411
+ { id: "retry", label: `Retry ${remembered.label}`, action: "retry" as const },
412
+ { id: "another", label: "Join another room", to: "joinAnother" as const },
413
+ { id: "forget", label: `Forget ${remembered.label}…`, to: "forget" as const },
414
+ { id: "settings", label: "Settings", to: "settings" as const },
415
+ { id: "status", label: "Status", to: "status" as const },
416
+ { id: "help", label: "Help", to: "help" as const },
417
+ ],
418
+ hint: "close" as const,
419
+ };
420
+ }
421
+ return {
422
+ kind: "actions" as const,
423
+ title: "Pi Chat · disconnected",
424
+ lines: ["Experimental peer-to-peer chat. Messages never enter model context."],
425
+ items: [
426
+ { id: "public", label: "Join public room", to: "joinPublic" as const },
427
+ { id: "invite", label: "Join with invite", to: "joinInvite" as const },
428
+ { id: "create", label: "Create private room", action: "createPrivate" as const },
429
+ { id: "settings", label: "Settings", to: "settings" as const },
430
+ { id: "status", label: "Status", to: "status" as const },
431
+ { id: "help", label: "Help", to: "help" as const },
432
+ ],
433
+ hint: "close" as const,
434
+ };
435
+ }
436
+ const restoresCurrent = remembered?.id === state.snapshot.room.id;
437
+ return {
438
+ kind: "actions" as const,
439
+ title: `Pi Chat · ${sanitizeSingleLine(state.snapshot.room.label)}`,
440
+ lines: [
441
+ `${state.snapshot.state} · ${state.snapshot.peers.length} direct peers · ${state.snapshot.unread} unread`,
442
+ `Current input: ${state.snapshot.composerOpen ? state.snapshot.room.label : "Pi/LLM"}`,
443
+ restoresCurrent
444
+ ? `Restart: restore this room and ${state.settings.resume?.surface === "chat" ? "open chat" : "stay in Pi/LLM"}`
445
+ : "Restart: this room will not reconnect",
446
+ state.snapshot.localLabel,
447
+ ],
448
+ items: [
449
+ {
450
+ id: "open",
451
+ label: `Open chat in ${sanitizeSingleLine(state.snapshot.room.label)}`,
452
+ action: "open" as const,
453
+ },
454
+ { id: "participants", label: "Show participants", to: "participants" as const },
455
+ ...(state.snapshot.room.invite
456
+ ? [{ id: "invite", label: "Show room invite", to: "invite" as const }]
457
+ : []),
458
+ { id: "settings", label: "Settings", to: "settings" as const },
459
+ { id: "status", label: "Status", to: "status" as const },
460
+ { id: "help", label: "Help", to: "help" as const },
461
+ {
462
+ id: "leave",
463
+ label: restoresCurrent ? "Leave and forget room…" : "Leave room…",
464
+ to: "leave" as const,
465
+ },
466
+ ],
467
+ hint: "close" as const,
468
+ };
469
+ }
470
+
471
+ function rememberedRoom(settings: ChatSettings): RoomDescriptor | undefined {
472
+ const resume = settings.resume;
473
+ const remembered = resume?.rooms.find(({ id }) => id === resume.activeRoomId);
474
+ if (!remembered) return undefined;
475
+ try {
476
+ return descriptorFromRememberedRoom(remembered);
477
+ } catch {
478
+ return undefined;
479
+ }
480
+ }
481
+
482
+ function restartDescription(settings: ChatSettings): string {
483
+ const room = rememberedRoom(settings);
484
+ if (!room) return "no room remembered";
485
+ return `${room.label} · ${settings.resume?.surface === "chat" ? "open chat" : "stay in Pi/LLM"}`;
486
+ }
487
+
488
+ function safeError(error: unknown): string {
489
+ return error instanceof Error ? error.message : String(error);
490
+ }