pi-roundtable-web 0.26.0 → 0.26.2

package/src/host/context.ts

@@ -54,22 +54,46 @@ function sourceOf(message: RoomMessage): Source {
 	};
 }
 
+/** What `WebApp.rooms.context` takes. */
+export interface HostRoomContextOptions {
+	/** The most messages to return, newest kept; default 15, at most 100. */
+	limit?: number;
+	/** The most characters of one message before it is cut with `…`; default 500. */
+	messageChars?: number;
+}
+
+/** The two ways a host room's recent messages are read. */
+export interface HostRoomContext {
+	/** For a turn the room's message addressed: marks what it returns as handed over. */
+	read(
+		message: InboundMessage,
+		options?: ChannelContextOptions,
+	): Promise<ChannelContext | undefined>;
+	/** For a host with no addressing message: the same block, and nothing is marked handed over. */
+	peek(
+		room: string,
+		options?: HostRoomContextOptions,
+	): Promise<ChannelContext | undefined>;
+}
+
 /**
- * The app surface's `channelContext` for a host room: what was said in it since the assistant
+ * The app surface's channel context of a host room: what was said in it since the assistant
  * last posted, before the message that addressed it, as the core's block of channel messages. An
  * outsider's words read as `external`, a notice line is not in the channel as far as the context
  * goes, and a message already handed to the conversation is not handed again. Anything but a host
- * room has none: an agent room is one person's.
+ * room has none: an agent room is one person's. `peek` reads the same block for the end of the
+ * room and leaves the handed-over marks alone, so a retry gets the same.
  */
-export function hostChannelContext(
+export function hostRoomContext(
 	ctx: Pick<HostContext, "registry" | "log">,
-): (
-	message: InboundMessage,
-	options?: ChannelContextOptions,
-) => Promise<ChannelContext | undefined> {
+): HostRoomContext {
 	const seen = new Map<string, Set<string>>();
-	return async (message, options = {}) => {
-		const room = message.channel;
+	const build = async (
+		room: string,
+		addressed: number | undefined,
+		options: ChannelContextOptions,
+		consume: boolean,
+	): Promise<ChannelContext | undefined> => {
 		if (!ctx.registry.isHostRoom(room)) return undefined;
 		const fetch = positive("fetch", options.fetch ?? DEFAULT_FETCH, PAGE_LIMIT);
 		const keep = positive("keep", options.keep ?? DEFAULT_KEEP, 100);
@@ -78,12 +102,7 @@ export function hostChannelContext(
 			options.messageChars ?? DEFAULT_CHARS,
 			20_000,
 		);
-		const addressed = /^app-(\d+)$/.exec(message.messageId)?.[1];
-		const page = await ctx.log.page(
-			room,
-			addressed === undefined ? undefined : Number(addressed),
-			fetch,
-		);
+		const page = await ctx.log.page(room, addressed, fetch);
 		const sources = page.messages.map((one) => ({
 			source: sourceOf(one),
 			notice: authorKindOf(one) === "notice",
@@ -99,24 +118,26 @@ export function hostChannelContext(
 		const lastEnd = considered.findLastIndex(
 			(entry) => verdict(entry) === "end",
 		);
-		const known = seen.get(room) ?? new Set<string>();
+		const known = consume ? (seen.get(room) ?? new Set<string>()) : undefined;
 		const fresh = considered
 			.slice(lastEnd + 1)
 			.filter(
 				(entry) =>
 					verdict(entry) === "keep" &&
-					!known.has(entry.source.id) &&
+					!known?.has(entry.source.id) &&
 					entry.source.text !== "",
 			)
 			.slice(-keep);
-		// What was in the window is not handed over again, kept or not.
-		for (const entry of considered.slice(lastEnd + 1))
-			known.add(entry.source.id);
-		seen.delete(room);
-		seen.set(room, new Set([...known].slice(-SEEN_PER_ROOM)));
-		if (seen.size > SEEN_ROOMS) {
-			const oldest = seen.keys().next().value;
-			if (oldest !== undefined) seen.delete(oldest);
+		if (known) {
+			// What was in the window is not handed over again, kept or not.
+			for (const entry of considered.slice(lastEnd + 1))
+				known.add(entry.source.id);
+			seen.delete(room);
+			seen.set(room, new Set([...known].slice(-SEEN_PER_ROOM)));
+			if (seen.size > SEEN_ROOMS) {
+				const oldest = seen.keys().next().value;
+				if (oldest !== undefined) seen.delete(oldest);
+			}
 		}
 		if (fresh.length === 0) return undefined;
 		const messages: ChannelContextMessage[] = fresh.map(({ source }) => ({
@@ -138,4 +159,30 @@ export function hostChannelContext(
 		}));
 		return { messages, text: formatChannelContext(messages) };
 	};
+	return {
+		read(message, options = {}) {
+			const addressed = /^app-(\d+)$/.exec(message.messageId)?.[1];
+			return build(
+				message.channel,
+				addressed === undefined ? undefined : Number(addressed),
+				options,
+				true,
+			);
+		},
+		peek(room, options = {}) {
+			const limit = options.limit ?? DEFAULT_KEEP;
+			return build(
+				room,
+				undefined,
+				{
+					keep: limit,
+					fetch: Math.min(PAGE_LIMIT, Math.max(DEFAULT_FETCH, limit * 3)),
+					...(options.messageChars === undefined
+						? {}
+						: { messageChars: options.messageChars }),
+				},
+				false,
+			);
+		},
+	};
 }

package/src/host/forms.ts

@@ -125,6 +125,7 @@ export function checkCard(card: {
 	state?: string | undefined;
 	links?: readonly { label: string; url: string }[] | undefined;
 	buttons?: readonly HostAction[] | undefined;
+	keep?: boolean | undefined;
 }): void {
 	if (typeof card.title !== "string" || card.title.length > LIMITS.title)
 		fail(`a card's title is at most ${LIMITS.title} characters`);
@@ -134,6 +135,8 @@ export function checkCard(card: {
 		fail(`a card's tone is note, ok, warn or risk`);
 	if (card.state !== undefined && !STATES.has(card.state))
 		fail(`a card's state is open, working, done, superseded or expired`);
+	if (card.keep !== undefined && typeof card.keep !== "boolean")
+		fail("a card's keep is true or false");
 	const links = card.links ?? [];
 	if (links.length > LIMITS.links)
 		fail(`a card takes at most ${LIMITS.links} links`);

package/src/host/frames.ts

@@ -60,7 +60,7 @@ export async function actInRoom(
 	if (press.card !== undefined) {
 		const card = await ctx.cards.get(room, press.card);
 		if (!card) return { refused: "unknown" };
-		offered = buttonsFor(viewer, found, access, card);
+		offered = await buttonsFor(viewer, found, access, card);
 	} else {
 		const header = await found.kind
 			.header?.(viewer, found.id)
@@ -146,6 +146,13 @@ export function installFrames(ctx: HostContext): void {
 						connection,
 						audience: { room: frame.room },
 					});
+			// So is a turn already running: a seat at the round table shows it from the first frame, not after the next change.
+			const activity = ctx.app.activityOf(asRoom(frame.room));
+			if (activity.typing)
+				ctx.sockets.deliver(
+					{ type: "activity", room: frame.room, ...activity },
+					{ connection, audience: { room: frame.room } },
+				);
 		},
 	);
 

package/src/host/host-app.ts

@@ -19,7 +19,7 @@ import type { Uploads } from "../app/uploads.ts";
 import type { Viewer, WebAppRegistry } from "../web-app.ts";
 import { HostAccess } from "./access.ts";
 import type { HostCardLog } from "./cards.ts";
-import { hostChannelContext } from "./context.ts";
+import { type HostRoomContext, hostRoomContext } from "./context.ts";
 import { installFrames } from "./frames.ts";
 import type { HostContext } from "./host-context.ts";
 import { hostArea, pagesArea } from "./host-routes.ts";
@@ -66,7 +66,7 @@ export class HostApp {
 	readonly rooms: HostRoomsService;
 	readonly pages: HostPagesService;
 	readonly #context: HostContext;
-	readonly #channelContext: ReturnType<typeof hostChannelContext>;
+	readonly #roomContext: HostRoomContext;
 
 	constructor(options: HostAppOptions) {
 		const now = options.now ?? Date.now;
@@ -102,6 +102,8 @@ export class HostApp {
 			maxFileBytes: options.maxFileBytes,
 			roomUrl: options.roomUrl,
 			listed,
+			context: (room, contextOptions) =>
+				this.#roomContext.peek(room, contextOptions),
 			now,
 			logger: options.logger,
 		});
@@ -126,7 +128,7 @@ export class HostApp {
 			now,
 			logger: options.logger,
 		};
-		this.#channelContext = hostChannelContext(this.#context);
+		this.#roomContext = hostRoomContext(this.#context);
 	}
 
 	/** Plugs the pieces into the registry: who reads, the frames, the areas, and the services a host reaches. */
@@ -153,7 +155,7 @@ export class HostApp {
 		message: InboundMessage,
 		options?: ChannelContextOptions,
 	): Promise<ChannelContext | undefined> {
-		return this.#channelContext(message, options);
+		return this.#roomContext.read(message, options);
 	}
 
 	/** Whether a stored file bound to a room or a page may be served to this viewer now. */

package/src/host/host-routes.ts

@@ -1,4 +1,4 @@
-import type { HostCardView, RoomMessage } from "../api-types.ts";
+import type { HostCardView, RoomMessage, SendWording } from "../api-types.ts";
 import { bad, bodyOf, HttpError } from "../app/api-http.ts";
 import { PAGE_LIMIT } from "../app/room-log.ts";
 import { json } from "../http.ts";
@@ -244,14 +244,15 @@ async function open(
 		ctx.log.page(room, undefined, OPEN_LIMIT),
 		ctx.cards.list(room),
 	]);
-	const cards: HostCardView[] = stored.map((card) =>
-		cardView(viewer, found, access, card),
+	const cards: HostCardView[] = await Promise.all(
+		stored.map((card) => cardView(viewer, found, access, card)),
 	);
 	return {
 		room,
 		kind: found.kind.kind,
 		id: found.id,
 		access: { send: [...access.send], act: access.act },
+		...wordingOf(found.kind.sendWording),
 		header,
 		messages: withExpiredFiles(page.messages, ctx.files),
 		more: page.more,
@@ -261,6 +262,38 @@ async function open(
 	};
 }
 
+/** The longest label and placeholder a kind may give, in characters. */
+const LABEL_CHARS = 40;
+const PLACEHOLDER_CHARS = 100;
+
+const trimmed = (value: unknown, chars: number): string | undefined =>
+	typeof value === "string"
+		? Array.from(value.trim()).slice(0, chars).join("") || undefined
+		: undefined;
+
+/** The kind's wording of the two ways to write as the page may show it: text only, cut short; nothing when it gave none. */
+function wordingOf(wording: SendWording | undefined): {
+	wording?: SendWording;
+} {
+	const note = trimmed(wording?.note?.placeholder, PLACEHOLDER_CHARS);
+	const label = trimmed(wording?.turn?.label, LABEL_CHARS);
+	const turn = trimmed(wording?.turn?.placeholder, PLACEHOLDER_CHARS);
+	if (!note && !label && !turn) return {};
+	return {
+		wording: {
+			...(note ? { note: { placeholder: note } } : {}),
+			...(label || turn
+				? {
+						turn: {
+							...(label ? { label } : {}),
+							...(turn ? { placeholder: turn } : {}),
+						},
+					}
+				: {}),
+		},
+	};
+}
+
 async function older(
 	ctx: HostContext,
 	viewer: Viewer,

package/src/host/room-views.ts

@@ -77,27 +77,27 @@ export interface FoundRoom {
  * The buttons of a host card this viewer may press: none once the card is settled, none without
  * `access.act`, and otherwise the card's own, narrowed by the kind's `buttons` when it has one.
  */
-export function buttonsFor(
+export async function buttonsFor(
 	viewer: Viewer,
 	found: FoundRoom,
 	access: RoomAccess,
 	card: StoredHostCard,
-): NonNullable<StoredHostCard["buttons"]> {
+): Promise<NonNullable<StoredHostCard["buttons"]>> {
 	const all = card.buttons ?? [];
 	if (!access.act || !pressable(card) || all.length === 0) return [];
 	if (!found.kind.buttons) return all;
-	const allowed = new Set(found.kind.buttons(viewer, found.id, card));
+	const allowed = new Set(await found.kind.buttons(viewer, found.id, card));
 	return all.filter((button) => allowed.has(button.id));
 }
 
 /** A host card as one viewer sees it. */
-export function cardView(
+export async function cardView(
 	viewer: Viewer,
 	found: FoundRoom,
 	access: RoomAccess,
 	card: StoredHostCard,
-): HostCardView {
-	const buttons = buttonsFor(viewer, found, access, card);
+): Promise<HostCardView> {
+	const buttons = await buttonsFor(viewer, found, access, card);
 	return {
 		id: card.id,
 		room: card.room,

package/src/host/rooms-service.ts

@@ -1,5 +1,6 @@
 import type { ChannelKey, Logger } from "pi-roundtable";
 import { PluginError } from "pi-roundtable";
+import type { ChannelContext } from "pi-roundtable/discord";
 import type { ServerFrame } from "../api-types.ts";
 import { MAX_MESSAGE_CHARS } from "../api-types.ts";
 import { type FileDir, isFileId, safeName } from "../app/files.ts";
@@ -15,6 +16,7 @@ import type {
 } from "../web-app.ts";
 import type { HostAccess } from "./access.ts";
 import type { HostCardLog } from "./cards.ts";
+import type { HostRoomContextOptions } from "./context.ts";
 import { checkCard } from "./forms.ts";
 import { cardView, checkPicture, type FoundRoom } from "./room-views.ts";
 
@@ -37,6 +39,11 @@ export interface HostRoomsOptions {
 	roomUrl(room: ChannelKey, message?: number): string;
 	/** Which kinds a person's last list showed, so the list's changes reach only them. */
 	listed: ListedKinds;
+	/** A room's recent messages as a channel-context block, without marking them handed over. */
+	context(
+		room: string,
+		options?: HostRoomContextOptions,
+	): Promise<ChannelContext | undefined>;
 	now?: () => number;
 	logger: Logger;
 }
@@ -272,6 +279,14 @@ export class HostRoomsService implements HostRooms {
 		return this.#options.log.byReference(room, reference);
 	}
 
+	async context(
+		room: ChannelKey,
+		options?: HostRoomContextOptions,
+	): Promise<ChannelContext | undefined> {
+		this.#found(room);
+		return this.#options.context(room, options);
+	}
+
 	// ── Cards ──
 
 	async card(room: ChannelKey, card: HostCard): Promise<{ id: string }> {
@@ -313,7 +328,7 @@ export class HostRoomsService implements HostRooms {
 					{
 						type: "host_card",
 						room,
-						card: cardView(viewer, found, access, stored),
+						card: await cardView(viewer, found, access, stored),
 					},
 					{ connection, audience: { room } },
 				);

package/src/host/views.ts

@@ -8,6 +8,7 @@ import type {
 	PictureRef,
 	ReadMarkView,
 	RoomMessage,
+	SendWording,
 } from "../api-types.ts";
 
 /** One room of a kind, as the list shows it. */
@@ -47,6 +48,8 @@ export interface HostRoomView {
 	id: string;
 	/** What this viewer may do in the room. */
 	access: { send: ("note" | "turn")[]; act: boolean };
+	/** The kind's own wording of the two ways to write, where it gave any. */
+	wording?: SendWording;
 	header: HostHeaderView;
 	/** The newest messages, oldest first. */
 	messages: RoomMessage[];