pi-roundtable-web 0.7.2 → 0.7.3

package/src/index.ts

@@ -5,16 +5,21 @@ export type {
 	ApiError,
 	ChannelName,
 	ConfigView,
+	ConnectorsView,
 	ContextView,
 	ConversationKind,
 	ConversationsView,
 	ConversationView,
+	DashboardView,
 	GroupView,
 	NoteInput,
 	NoteKind,
 	NoteView,
 	OverviewView,
 	PaneName,
+	PartyView,
+	SkillDetailView,
+	SkillView,
 	TranscriptEntry,
 	TranscriptRole,
 	TranscriptView,
@@ -22,6 +27,9 @@ export type {
 export { PANES } from "./api-types.ts";
 export type { CloudflareAccessOptions } from "./cloudflare-access.ts";
 export { cloudflareAccess } from "./cloudflare-access.ts";
+/** Summary for a trusted host's separately stored party sessions. */
+export { conversationFiles as sessionSummary } from "./conversations.ts";
+export type { ConsoleFeatures, ConsolePresentation } from "./features.ts";
 export type { WebConsoleOptions } from "./options.ts";
 export { DEFAULT_RELAY_NOTE } from "./options.ts";
 export type { RequestVerifier, Verdict } from "./verifier.ts";

package/src/options.ts

@@ -1,7 +1,8 @@
 import { join } from "node:path";
-import type { ChannelKey } from "pi-roundtable";
+import type { ChannelKey, RoundtablePlugin } from "pi-roundtable";
 import { PluginError } from "pi-roundtable";
 import { PANES, type PaneName } from "./api-types.ts";
+import type { ConsoleFeatures, ConsolePresentation } from "./features.ts";
 import type { RequestVerifier } from "./verifier.ts";
 
 /**
@@ -17,6 +18,14 @@ export interface WebConsoleOptions {
 	 * built-in one. Without it the plugin refuses to start rather than serve without authentication.
 	 */
 	verifier: RequestVerifier;
+	/** Host-specific data and actions, resolved against public plugin setup context. */
+	features?:
+		| ConsoleFeatures
+		| ((
+				context: Parameters<RoundtablePlugin["setup"]>[0],
+		  ) => ConsoleFeatures | Promise<ConsoleFeatures>);
+	/** Localized labels and error text; English source strings are dictionary keys. */
+	presentation?: ConsolePresentation;
 	/**
 	 * The console's own origin, such as `https://console.example.com`: requests that change data
 	 * must carry it as their `Origin`, and the dashboard line links to it.
@@ -30,6 +39,8 @@ export interface WebConsoleOptions {
 	mountPath?: string;
 	/** The listener whose address serves it; default `public`. */
 	listener?: string;
+	/** Hash routes by default; path routes retain links such as /console/skills. */
+	routing?: "hash" | "path";
 	/** The panes to serve, in the order the page lists them; default all of `overview`, `conversations`, `notes`. */
 	panes?: readonly PaneName[];
 	/** The page's title and heading; default `Roundtable`. */
@@ -50,11 +61,14 @@ export interface ResolvedOptions {
 	sessionsDir: string;
 	mount: string;
 	listener: string;
+	routing: "hash" | "path";
 	panes: PaneName[];
 	title: string;
 	relayNotes: readonly string[];
 	exclude: ((key: ChannelKey) => boolean) | undefined;
 	assetDir: string | undefined;
+	features: WebConsoleOptions["features"];
+	presentation: ConsolePresentation | undefined;
 }
 
 const SEGMENT = /^[A-Za-z0-9._~-]+$/;
@@ -99,7 +113,7 @@ function checkOrigin(origin: string): string {
 }
 
 function checkPanes(panes: readonly PaneName[] | undefined): PaneName[] {
-	if (panes === undefined) return [...PANES];
+	if (panes === undefined) return ["overview", "conversations", "notes"];
 	if (panes.length === 0) fail("panes is empty; serve at least one pane");
 	for (const pane of panes)
 		if (!PANES.includes(pane))
@@ -116,6 +130,19 @@ export function resolveOptions(options: WebConsoleOptions): ResolvedOptions {
 		fail(
 			"no verifier. The console serves the owner's conversations and notes, so it will not start without one that authenticates every request; pass `verifier: cloudflareAccess({...})` or your own",
 		);
+	if (
+		options.routing !== undefined &&
+		options.routing !== "path" &&
+		options.routing !== "hash"
+	)
+		fail("routing must be hash or path");
+	if (options.presentation?.locale !== undefined) {
+		try {
+			new Intl.DateTimeFormat(options.presentation.locale);
+		} catch {
+			fail("presentation.locale is not a valid locale");
+		}
+	}
 	const panes = checkPanes(options.panes);
 	const ownerId = options.ownerId?.trim();
 	if (panes.includes("notes") && !ownerId)
@@ -131,10 +158,13 @@ export function resolveOptions(options: WebConsoleOptions): ResolvedOptions {
 		sessionsDir: join(options.dataDir ?? "data", "sessions"),
 		mount: checkMount(options.mountPath ?? "/console"),
 		listener: options.listener ?? "public",
+		routing: options.routing ?? "hash",
 		panes,
 		title,
 		relayNotes: options.relayNotes ?? [DEFAULT_RELAY_NOTE],
 		exclude: options.exclude,
 		assetDir: options.assetDir,
+		features: options.features,
+		presentation: options.presentation,
 	};
 }

package/src/page-presentation.ts

@@ -0,0 +1,30 @@
+import type { ConsolePresentation } from "./features.ts";
+
+const attribute = (value: string): string =>
+	value
+		.replaceAll("&", "&")
+		.replaceAll('"', """)
+		.replaceAll("<", "&lt;")
+		.replaceAll(">", "&gt;")
+		.replaceAll("'", "&#39;");
+
+/** Authenticated, inert bootstrap data localizes even a failed first API request without inline scripts. */
+export function presentPage(
+	body: Uint8Array,
+	mount: string | undefined,
+	presentation: ConsolePresentation | undefined,
+): Uint8Array<ArrayBuffer> | string {
+	if (!mount && !presentation) return new Uint8Array(body);
+	let head = "<head>";
+	if (mount) head += `<base href="${attribute(`${mount}/`)}">`;
+	if (presentation)
+		head += `<meta name="roundtable-console-presentation" content="${attribute(JSON.stringify(presentation))}">`;
+	let html = new TextDecoder().decode(body).replace("<head>", () => head);
+	if (presentation?.locale)
+		html = html.replace(
+			/(<html[^>]*lang=")[^"]*(")/,
+			(_all, prefix: string, suffix: string) =>
+				`${prefix}${attribute(presentation.locale ?? "en")}${suffix}`,
+		);
+	return html;
+}

package/src/skills-api.ts

@@ -0,0 +1,77 @@
+import type { SkillDetailView, SkillView } from "./api-types.ts";
+import type { ConsoleFeatures } from "./features.ts";
+import { ConsoleHttpError as HttpError } from "./http.ts";
+
+/** Strip private file paths from a host catalog explicitly. */
+export function skillCatalog(
+	skills: NonNullable<ConsoleFeatures["skills"]>,
+): SkillView[] {
+	return skills
+		.catalog()
+		.map(({ name, source, description, missing, groups, carriers }) => ({
+			name,
+			source,
+			...(description ? { description } : {}),
+			...(missing ? { missing } : {}),
+			groups,
+			carriers,
+		}));
+}
+
+/** Read a catalog-selected skill, bound its document, and return ordered frontmatter. */
+export async function skillDetail(
+	skills: NonNullable<ConsoleFeatures["skills"]>,
+	name: string,
+): Promise<SkillDetailView> {
+	const entry = skills.catalog().find((s) => s.name === name);
+	if (!entry) throw new HttpError(404, "There is no such skill.");
+	if (entry.missing) throw new HttpError(404, "The skill file is missing.");
+	try {
+		const parsed = await skills.read(name);
+		if (
+			Buffer.byteLength(parsed.body) > 1024 * 1024 ||
+			Buffer.byteLength(JSON.stringify(parsed.frontmatter)) > 64 * 1024
+		)
+			throw new HttpError(413, "The skill file is too large.");
+		return {
+			name,
+			body: parsed.body,
+			metadata: metadataEntries(parsed.frontmatter),
+		};
+	} catch (error) {
+		if (error instanceof HttpError) throw error;
+		throw new HttpError(422, "The skill frontmatter could not be read.");
+	}
+}
+
+/** Flatten nested frontmatter in source order, keeping scalar/array values readable. */
+function metadataEntries(
+	record: Record<string, unknown>,
+	prefix = "",
+	depth = 0,
+): SkillDetailView["metadata"] {
+	return Object.entries(record).flatMap(([key, value]) => {
+		const path = prefix ? `${prefix}.${key}` : key;
+		if (
+			depth < 20 &&
+			value !== null &&
+			typeof value === "object" &&
+			!Array.isArray(value)
+		)
+			return metadataEntries(value as Record<string, unknown>, path, depth + 1);
+		return [
+			{
+				key: path,
+				value: Array.isArray(value)
+					? value
+							.map((v) =>
+								typeof v === "object" ? JSON.stringify(v) : String(v ?? ""),
+							)
+							.join(", ")
+					: typeof value === "object" && value !== null
+						? JSON.stringify(value)
+						: String(value ?? ""),
+			},
+		];
+	});
+}

package/src/web-plugin.ts

@@ -33,8 +33,16 @@ export function webConsole(options: WebConsoleOptions): RoundtablePlugin {
 
 type Context = Parameters<RoundtablePlugin["setup"]>[0];
 
-function build(settings: ResolvedOptions, context: Context) {
+async function build(settings: ResolvedOptions, context: Context) {
 	const { services, queue, logger, env } = context;
+	const features =
+		typeof settings.features === "function"
+			? await settings.features(context)
+			: settings.features;
+	for (const pane of ["skills", "connectors"] as const) {
+		if (settings.panes.includes(pane) && !features?.[pane])
+			throw new Error(`web-console: the ${pane} pane needs its feature port`);
+	}
 	const team = services.find(AGENTS)?.team;
 	const connection = services.find(DISCORD)?.connection;
 	const listeners: (() => void)[] = [];
@@ -60,12 +68,17 @@ function build(settings: ResolvedOptions, context: Context) {
 		relayNotes: settings.relayNotes,
 		changed,
 		logger,
+		...(features ? { features } : {}),
+		...(settings.routing === "path" ? { mountPath: settings.mount } : {}),
+		...(settings.presentation ? { presentation: settings.presentation } : {}),
 	});
 	const server = new ConsoleServer({
 		mount: settings.mount,
 		assets,
 		verifier: settings.verifier,
 		origin: settings.origin,
+		pathRouting: settings.routing === "path",
+		...(settings.presentation ? { presentation: settings.presentation } : {}),
 		api,
 		subscribe: (listener) => {
 			listeners.push(listener);