pi-roundtable-web 0.7.0 → 0.7.3

package/dist/index.html

@@ -5,7 +5,7 @@
 		<meta name="viewport" content="width=device-width, initial-scale=1" />
 		<title>Console</title>
 		
-	<link rel="stylesheet" crossorigin href="./chunk-e8z9q554.css"><script type="module" crossorigin src="./chunk-gkh6x5ag.js"></script></head>
+	<link rel="stylesheet" crossorigin href="./chunk-e8z9q554.css"><script type="module" crossorigin src="./chunk-32sbjm56.js"></script></head>
 	<body>
 		<div id="root"></div>
 		

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-roundtable-web",
-	"version": "0.7.0",
+	"version": "0.7.3",
 	"description": "An owner-only web console for pi-roundtable: conversations, transcripts, and memory notes, with live updates",
 	"type": "module",
 	"license": "MIT",
@@ -47,9 +47,11 @@
 		"@types/bun": "1.4.2",
 		"@types/react": "19.3.0",
 		"@types/react-dom": "19.3.0",
-		"pi-roundtable": "0.7.0",
+		"pi-roundtable": "0.7.3",
 		"react": "19.3.0",
 		"react-dom": "19.3.0",
+		"react-markdown": "10.1.0",
+		"remark-gfm": "4.0.1",
 		"typescript": "7.0.2"
 	}
 }

package/src/api-types.ts

@@ -1,7 +1,13 @@
 // The console's API shapes, shared by the server (`src/`) and the page (`web/`). Times are ISO strings.
 
 /** The panes the console can show; the options choose which ones a host serves. */
-export const PANES = ["overview", "conversations", "notes"] as const;
+export const PANES = [
+	"overview",
+	"conversations",
+	"notes",
+	"skills",
+	"connectors",
+] as const;
 export type PaneName = (typeof PANES)[number];
 
 /** What the page needs before it can draw anything. */
@@ -10,6 +16,12 @@ export interface ConfigView {
 	panes: PaneName[];
 	/** The IANA zone the page formats times and event dates in: the host's `env.timeZone`. */
 	timeZone: string;
+	locale?: string;
+	messages?: Readonly<Record<string, string>>;
+	cleanup?: boolean;
+	connectorAdminUrl?: string;
+	/** Only supplied for path-based routing; also the base for page/API URLs. */
+	mountPath?: string;
 }
 
 export type ChannelName =
@@ -53,6 +65,19 @@ export interface OverviewView {
 	guildId: string;
 	agents: AgentView[];
 	groups: GroupView[];
+	workspaces?: (ConversationView & { schedules: number })[];
+	outside?: ConversationView[];
+	party?: PartyView[];
+}
+
+/** Compatibility dashboard shape for hosts migrating an existing console endpoint. */
+export interface DashboardView {
+	agentGuildId: string;
+	agents: (AgentView & { key: string })[];
+	groups: (GroupView & { key: string })[];
+	workspaces: (ConversationView & { channelId: string; schedules: number })[];
+	outside: (ConversationView & { sessionId: string })[];
+	party: PartyView[];
 }
 
 /** Who a stored conversation belongs to. */
@@ -122,6 +147,46 @@ export interface NoteInput {
 	eventDate?: string;
 }
 
+export interface PartyView {
+	key: string;
+	channelId: string;
+	channel: ChannelName;
+	profile: string;
+	enabledBy: string;
+	enabledAt: string;
+	container: "missing" | "running" | "stopped" | "unknown";
+	busy: number;
+	lastActive?: string;
+}
+
+export interface SkillView {
+	name: string;
+	source:
+		| { kind: "builtin" }
+		| { kind: "linked"; repo: string; path: string }
+		| { kind: "written" };
+	description?: string;
+	missing?: string;
+	groups: string[];
+	carriers: string[];
+}
+
+export interface SkillDetailView {
+	name: string;
+	metadata: { key: string; value: string }[];
+	body: string;
+}
+
+export interface ConnectorsView {
+	gateways: {
+		name: string;
+		enabled: boolean;
+		reachable: boolean;
+		tools: number;
+	}[];
+	servers: { name: string; tools: string[]; usedBy: string[] }[];
+}
+
 /** Every error body the API returns. */
 export interface ApiError {
 	error: string;

package/src/cleanup-api.ts

@@ -0,0 +1,54 @@
+import { join } from "node:path";
+import type { AgentTeam, ChannelKey } from "pi-roundtable";
+import { conversationFiles, parseKey } from "./conversations.ts";
+import type { ConsoleFeatures } from "./features.ts";
+import { ConsoleHttpError as HttpError, json } from "./http.ts";
+
+interface CleanupPorts {
+	features?: ConsoleFeatures;
+	exclude?: (key: ChannelKey) => boolean;
+	team?: Pick<AgentTeam, "owns" | "status">;
+	sessionsDir: string;
+	changed(): void;
+}
+
+/** The console validates ownership before invoking destructive host operations. */
+export async function cleanupConversation(
+	ports: CleanupPorts,
+	raw: string,
+	action: "start-over" | "delete",
+): Promise<Response> {
+	const { features, exclude, team, sessionsDir } = ports;
+	const cleanup = features?.cleanup;
+	const key = raw as ChannelKey;
+	const parsed = parseKey(raw);
+	if (!cleanup || !parsed || parsed.kind === "group" || exclude?.(key))
+		throw new HttpError(404, "There is no such conversation.");
+	const owned =
+		Boolean(team?.owns(key)) || Boolean(features?.party?.contains(key));
+	const group =
+		(await team?.status())?.groups.some(
+			(g) => `discord:${g.channelId}` === key,
+		) ?? false;
+	const stored =
+		!owned &&
+		!group &&
+		Boolean(conversationFiles(join(sessionsDir, parsed.dir)));
+	if (action === "delete") {
+		if (!stored)
+			throw new HttpError(
+				404,
+				"Only workspace and outside conversations can be deleted.",
+			);
+		const result = await cleanup.deleteConversation(key);
+		if (result === "busy")
+			throw new HttpError(409, "The conversation is busy. Try again later.");
+		ports.changed();
+		return json({ result });
+	}
+	if (!owned && !group && !stored)
+		throw new HttpError(404, "There is no such conversation.");
+	const kind = await cleanup.startFresh(key);
+	ports.changed();
+	return json({ kind });
+}

package/src/connectors-api.ts

@@ -0,0 +1,26 @@
+import type { ConnectorsView } from "./api-types.ts";
+import type { ConsoleFeatures } from "./features.ts";
+import { ConsoleHttpError as HttpError } from "./http.ts";
+
+export async function connectorsView(
+	connectors: NonNullable<ConsoleFeatures["connectors"]>,
+): Promise<ConnectorsView> {
+	try {
+		const [gateways, servers] = await Promise.all([
+			connectors.gateways(),
+			connectors.servers(),
+		]);
+		return {
+			gateways,
+			servers: servers.map((server) => ({
+				...server,
+				usedBy: connectors.usedBy(server.name),
+			})),
+		};
+	} catch {
+		throw new HttpError(
+			502,
+			"The connector service did not respond. Try again later.",
+		);
+	}
+}

package/src/console-api.ts

@@ -16,6 +16,7 @@ import type {
 	ConversationKind,
 	ConversationsView,
 	ConversationView,
+	DashboardView,
 	NoteInput,
 	NoteView,
 	OverviewView,
@@ -31,6 +32,13 @@ import {
 	storedConversations,
 } from "./conversations.ts";
 
+import {
+	type ConsoleFeatures,
+	type ConsolePresentation,
+	message,
+	safeAdminUrl,
+} from "./features.ts";
+
 const NOTE_SEARCH_LIMIT = 500;
 /** The largest note body the console reads. */
 const MAX_BODY_BYTES = 64 * 1024;
@@ -58,22 +66,15 @@ export interface ConsolePorts {
 	/** Called after a note is written, so every open page refreshes. */
 	changed(): void;
 	logger: Logger;
+	features?: ConsoleFeatures;
+	presentation?: ConsolePresentation;
+	mountPath?: string;
 }
 
-class HttpError extends Error {
-	constructor(
-		readonly status: number,
-		message: string,
-	) {
-		super(message);
-	}
-}
-
-const json = (body: unknown, status = 200) =>
-	Response.json(body, {
-		status,
-		headers: { "cache-control": "no-store" },
-	});
+import { cleanupConversation } from "./cleanup-api.ts";
+import { connectorsView } from "./connectors-api.ts";
+import { ConsoleHttpError as HttpError, json } from "./http.ts";
+import { skillCatalog, skillDetail } from "./skills-api.ts";
 
 /** Memory refusals as the Notes pane shows them. */
 const MEMORY_REASONS: Record<string, string> = {
@@ -105,14 +106,27 @@ export class ConsoleApi {
 			return await this.#route(request, path);
 		} catch (error) {
 			if (error instanceof HttpError)
-				return json({ error: error.message } satisfies ApiError, error.status);
+				return json(
+					{
+						error: message(this.#ports.presentation, error.message),
+					} satisfies ApiError,
+					error.status,
+				);
 			if (error instanceof MemoryError)
-				return json({ error: memoryReason(error) } satisfies ApiError, 400);
+				return json(
+					{
+						error: message(this.#ports.presentation, memoryReason(error)),
+					} satisfies ApiError,
+					400,
+				);
 			// The URL stays out of the log: a path may hold something private.
 			this.#ports.logger.error({ err: error }, "console api failed");
 			return json(
 				{
-					error: "The console could not complete the request.",
+					error: message(
+						this.#ports.presentation,
+						"The console could not complete the request.",
+					),
 				} satisfies ApiError,
 				500,
 			);
@@ -135,9 +149,31 @@ export class ConsoleApi {
 		const [head, id] = parts;
 		if (method === "GET" && head === "config" && !id)
 			return json(this.config());
-		if (method === "GET" && head === "overview" && !id) {
+		if (
+			method === "GET" &&
+			(head === "overview" || head === "dashboard") &&
+			!id
+		) {
 			this.#pane("overview");
-			return json(await this.overview());
+			const view = await this.overview();
+			if (head === "overview") return json(view);
+			return json({
+				agentGuildId: view.guildId,
+				agents: view.agents.map((agent) => ({
+					...agent,
+					key: agent.channelId ? `discord:${agent.channelId}` : "",
+				})),
+				groups: view.groups.map((group) => ({
+					...group,
+					key: `discord:${group.channelId}`,
+				})),
+				workspaces: (view.workspaces ?? []).map((c) => ({
+					...c,
+					channelId: c.id,
+				})),
+				outside: (view.outside ?? []).map((c) => ({ ...c, sessionId: c.id })),
+				party: view.party ?? [],
+			} satisfies DashboardView);
 		}
 		if (method === "GET" && head === "conversations" && parts.length <= 2) {
 			this.#pane("conversations");
@@ -145,6 +181,23 @@ export class ConsoleApi {
 			const archive = new URL(request.url).searchParams.get("archive");
 			return json(await this.transcript(id, archive ?? undefined));
 		}
+		if (method === "POST" && head === "channels" && id && parts.length === 3) {
+			this.#pane("overview");
+			if (parts[2] === "start-over" || parts[2] === "delete")
+				return cleanupConversation(this.#ports, id, parts[2]);
+		}
+		if (method === "GET" && head === "skills" && parts.length <= 2) {
+			this.#pane("skills");
+			const skills = this.#ports.features?.skills;
+			if (!skills) throw new HttpError(404, "This pane is not served.");
+			return json(id ? await skillDetail(skills, id) : skillCatalog(skills));
+		}
+		if (method === "GET" && head === "connectors" && parts.length === 1) {
+			this.#pane("connectors");
+			const connectors = this.#ports.features?.connectors;
+			if (!connectors) throw new HttpError(404, "This pane is not served.");
+			return json(await connectorsView(connectors));
+		}
 		if (head === "notes" && parts.length <= 2) {
 			this.#pane("notes");
 			return this.#notes(request, id);
@@ -154,7 +207,18 @@ export class ConsoleApi {
 
 	config(): ConfigView {
 		const { title, panes, timeZone } = this.#ports;
-		return { title, panes: [...panes], timeZone };
+		const { presentation, features } = this.#ports;
+		const connectorAdminUrl = safeAdminUrl(features?.connectors?.adminUrl);
+		return {
+			title,
+			panes: [...panes],
+			timeZone,
+			...(presentation?.locale ? { locale: presentation.locale } : {}),
+			...(presentation?.messages ? { messages: presentation.messages } : {}),
+			...(features?.cleanup ? { cleanup: true } : {}),
+			...(connectorAdminUrl ? { connectorAdminUrl } : {}),
+			...(this.#ports.mountPath ? { mountPath: this.#ports.mountPath } : {}),
+		};
 	}
 
 	// ── Overview ───────────────────────────────────────────────────────────
@@ -163,7 +227,23 @@ export class ConsoleApi {
 		const { team } = this.#ports;
 		if (!team) throw new HttpError(404, "This pane is not served.");
 		const status = await team.status();
+		const { features } = this.#ports;
+		const stored = (await this.conversations()).conversations.filter(
+			(c) => c.kind === "owner" || c.kind === "outside",
+		);
+		const workspaces = await Promise.all(
+			stored
+				.filter((c) => c.kind === "owner")
+				.map(async (c) => ({
+					...c,
+					schedules:
+						(await features?.schedules?.count(c.key as ChannelKey)) ?? 0,
+				})),
+		);
 		return {
+			workspaces,
+			outside: stored.filter((c) => c.kind === "outside"),
+			party: (await features?.party?.list()) ?? [],
 			guildId: team.guildId,
 			agents: status.agents.map((agent) => ({
 				name: agent.name,
@@ -194,7 +274,9 @@ export class ConsoleApi {
 	async conversations(): Promise<ConversationsView> {
 		const { sessionsDir, relayNotes, exclude } = this.#ports;
 		const stored = storedConversations(sessionsDir, {
-			excluded: (key) => exclude?.(key) ?? false,
+			excluded: (key) =>
+				(exclude?.(key) ?? false) ||
+				(this.#ports.features?.party?.contains(key) ?? false),
 			relayNotes,
 		});
 		return {
@@ -208,7 +290,11 @@ export class ConsoleApi {
 	): Promise<TranscriptView> {
 		const { sessionsDir, relayNotes, exclude } = this.#ports;
 		const parsed = parseKey(key);
-		if (!parsed || exclude?.(key as ChannelKey))
+		if (
+			!parsed ||
+			exclude?.(key as ChannelKey) ||
+			this.#ports.features?.party?.contains(key as ChannelKey)
+		)
 			throw new HttpError(404, "There is no such conversation.");
 		const dir = join(sessionsDir, parsed.dir);
 		const files = conversationFiles(dir);

package/src/console-server.ts

@@ -1,6 +1,8 @@
 import type { HttpRoute, Logger } from "pi-roundtable";
 import type { AssetBundle } from "./assets.ts";
 import type { ConsoleApi } from "./console-api.ts";
+import type { ConsolePresentation } from "./features.ts";
+import { presentPage } from "./page-presentation.ts";
 import type { RequestVerifier } from "./verifier.ts";
 
 const encoder = new TextEncoder();
@@ -39,6 +41,9 @@ export interface ConsoleServerOptions {
 	logger: Logger;
 	/** How long changes are gathered into one event; default 250 ms. Tests set it lower. */
 	coalesceMs?: number;
+	/** Serve client page paths as the same authenticated document. */
+	pathRouting?: boolean;
+	presentation?: ConsolePresentation;
 }
 
 /**
@@ -106,12 +111,7 @@ export class ConsoleServer {
 	async #respond(request: Request): Promise<Response> {
 		// pi-lens-ignore: unchecked-throwing-call -- the server builds request.url, always an absolute URL
 		const path = new URL(request.url).pathname;
-		if (path === this.#options.mount)
-			return new Response(null, {
-				status: 302,
-				headers: { location: this.#base },
-			});
-		if (!path.startsWith(this.#base))
+		if (path !== this.#options.mount && !path.startsWith(this.#base))
 			return new Response("Not found", { status: 404 });
 		const refusal = await this.#refusal(request);
 		if (refusal !== undefined) {
@@ -121,6 +121,11 @@ export class ConsoleServer {
 				headers: { "cache-control": "no-store" },
 			});
 		}
+		if (path === this.#options.mount)
+			return new Response(null, {
+				status: 302,
+				headers: { location: this.#base },
+			});
 		const rest = path.slice(this.#base.length);
 		if (rest === "api/events" && request.method === "GET")
 			return this.#events();
@@ -128,18 +133,37 @@ export class ConsoleServer {
 			return this.#options.api.handle(request, rest.slice("api/".length));
 		if (!READ_METHODS.has(request.method))
 			return new Response("Method not allowed", { status: 405 });
-		if (rest === "" || rest === "index.html") {
-			const page = this.#options.assets.get("index.html");
-			if (page) return new Response(page.body, { headers: PAGE_HEADERS });
-		}
 		const asset = this.#options.assets.get(rest);
 		if (asset && rest !== "index.html")
-			return new Response(asset.body, {
+			return new Response(new Uint8Array(asset.body), {
 				headers: {
 					"content-type": asset.type,
 					"cache-control": "private, max-age=31536000, immutable",
 				},
 			});
+		if (rest === "" || rest === "index.html" || this.#options.pathRouting) {
+			const page = this.#options.assets.get("index.html");
+			if (page)
+				return new Response(
+					presentPage(
+						page.body,
+						this.#options.pathRouting ? this.#options.mount : undefined,
+						this.#options.presentation,
+					),
+					{
+						headers: {
+							...PAGE_HEADERS,
+							...(this.#options.pathRouting
+								? {
+										"content-security-policy": PAGE_HEADERS[
+											"content-security-policy"
+										].replace("base-uri 'none'", "base-uri 'self'"),
+									}
+								: {}),
+						},
+					},
+				);
+		}
 		return new Response("Not found", { status: 404 });
 	}
 

package/src/conversations.ts

@@ -2,9 +2,9 @@ import {
 	closeSync,
 	existsSync,
 	fstatSync,
+	lstatSync,
 	openSync,
 	readdirSync,
-	readFileSync,
 	readSync,
 	statSync,
 } from "node:fs";
@@ -82,21 +82,22 @@ export function parseKey(
  * folders, as `archiveSessions` leaves them. Undefined when the directory does not exist.
  */
 export function conversationFiles(dir: string): ConversationFiles | undefined {
-	if (!existsSync(dir)) return undefined;
+	if (!existsSync(dir) || !lstatSync(dir).isDirectory()) return undefined;
 	let liveBytes = 0;
 	let newest = 0;
-	for (const file of readdirSync(dir)) {
-		if (!file.endsWith(".jsonl")) continue;
-		const stat = statSync(join(dir, file));
+	for (const file of readdirSync(dir, { withFileTypes: true })) {
+		if (!file.isFile() || !file.name.endsWith(".jsonl")) continue;
+		const stat = statSync(join(dir, file.name));
 		liveBytes += stat.size;
 		newest = Math.max(newest, stat.mtimeMs);
 	}
 	const archiveDir = join(dir, "archive");
-	const archives = existsSync(archiveDir)
-		? readdirSync(archiveDir, { withFileTypes: true }).filter((entry) =>
-				entry.isDirectory(),
-			)
-		: [];
+	const archives =
+		existsSync(archiveDir) && lstatSync(archiveDir).isDirectory()
+			? readdirSync(archiveDir, { withFileTypes: true }).filter((entry) =>
+					entry.isDirectory(),
+				)
+			: [];
 	if (newest === 0)
 		for (const archive of archives)
 			newest = Math.max(
@@ -133,8 +134,9 @@ function withoutRelayNote(text: string, notes: readonly string[]): string {
 
 /** The `.jsonl` file names directly in a directory, oldest first; names start with their creation time. */
 function sessionFiles(dir: string): string[] {
-	return readdirSync(dir)
-		.filter((file) => file.endsWith(".jsonl"))
+	return readdirSync(dir, { withFileTypes: true })
+		.filter((file) => file.isFile() && file.name.endsWith(".jsonl"))
+		.map((file) => file.name)
 		.sort();
 }
 
@@ -164,8 +166,11 @@ function opening(
 	const archiveDir = join(dir, "archive");
 	const first = sessionFiles(dir)[0];
 	let file = first ? join(dir, first) : undefined;
-	if (!file && existsSync(archiveDir))
-		for (const archive of readdirSync(archiveDir).sort()) {
+	if (!file && existsSync(archiveDir) && lstatSync(archiveDir).isDirectory())
+		for (const archive of readdirSync(archiveDir, { withFileTypes: true })
+			.filter((entry) => entry.isDirectory())
+			.map((entry) => entry.name)
+			.sort()) {
 			const name = sessionFiles(join(archiveDir, archive))[0];
 			if (name) {
 				file = join(archiveDir, archive, name);
@@ -251,7 +256,8 @@ export function storedConversations(
 /** The archive folders of a conversation, newest first. */
 export function archiveNames(dir: string): string[] {
 	const archiveDir = join(dir, "archive");
-	if (!existsSync(archiveDir)) return [];
+	if (!existsSync(archiveDir) || !lstatSync(archiveDir).isDirectory())
+		return [];
 	return readdirSync(archiveDir, { withFileTypes: true })
 		.filter((entry) => entry.isDirectory())
 		.map((entry) => entry.name)
@@ -270,12 +276,12 @@ function readTail(
 	const fd = openSync(path, "r");
 	try {
 		const { size } = fstatSync(fd);
-		if (size <= limit)
-			return { text: readFileSync(fd, "utf8"), cut: false, read: size };
-		const buffer = Buffer.alloc(limit);
-		readSync(fd, buffer, 0, limit, size - limit);
-		const text = buffer.toString("utf8");
-		return { text: text.slice(text.indexOf("\n") + 1), cut: true, read: limit };
+		const length = Math.min(size, limit);
+		const buffer = Buffer.alloc(length);
+		const read = readSync(fd, buffer, 0, length, Math.max(0, size - limit));
+		const text = buffer.subarray(0, read).toString("utf8");
+		const cut = size > limit;
+		return { text: cut ? text.slice(text.indexOf("\n") + 1) : text, cut, read };
 	} finally {
 		closeSync(fd);
 	}

package/src/features.ts

@@ -0,0 +1,59 @@
+import type { ChannelKey } from "pi-roundtable";
+import type { ConnectorsView, PartyView, SkillView } from "./api-types.ts";
+
+/** Trusted host integrations. They receive validated keys, never request-selected file paths. */
+export interface ConsoleFeatures {
+	party?: {
+		contains(key: ChannelKey): boolean;
+		/** The host binds its channel store, runtime status and existing session paths here. */
+		list(): Promise<PartyView[]>;
+	};
+	schedules?: { count(key: ChannelKey): Promise<number> };
+	cleanup?: {
+		/** Archives the conversation, preserving memory; the host waits for active turns. */
+		startFresh(key: ChannelKey): Promise<string>;
+		/** Only stored owner/outside conversations are admitted by the console. */
+		deleteConversation(key: ChannelKey): Promise<"deleted" | "busy">;
+	};
+	skills?: {
+		catalog(): SkillView[];
+		/** Read only the selected catalog entry, with a host-enforced byte limit. */
+		read(
+			name: string,
+		): Promise<{ frontmatter: Record<string, unknown>; body: string }>;
+	};
+	connectors?: {
+		gateways(): Promise<ConnectorsView["gateways"]>;
+		servers(): Promise<{ name: string; tools: string[] }[]>;
+		usedBy(server: string): string[];
+		/** Optional administrator link, limited to HTTP(S) or an absolute local path. */
+		adminUrl?: string;
+	};
+}
+
+/** English source strings are keys; a host supplies its own wording without a page fork. */
+export interface ConsolePresentation {
+	locale?: string;
+	messages?: Readonly<Record<string, string>>;
+}
+
+export function message(
+	presentation: ConsolePresentation | undefined,
+	source: string,
+): string {
+	return presentation?.messages?.[source] ?? source;
+}
+
+export function safeAdminUrl(url: string | undefined): string | undefined {
+	if (!url) return undefined;
+	if (url.startsWith("/") && !url.startsWith("//") && !url.includes("\\"))
+		return url;
+	try {
+		const parsed = new URL(url);
+		return parsed.protocol === "https:" || parsed.protocol === "http:"
+			? parsed.href
+			: undefined;
+	} catch {
+		return undefined;
+	}
+}

package/src/http.ts

@@ -0,0 +1,11 @@
+/** Fixed errors shared by console API adapters; request paths and upstream details stay private. */
+export class ConsoleHttpError extends Error {
+	constructor(
+		readonly status: number,
+		message: string,
+	) {
+		super(message);
+	}
+}
+export const json = (body: unknown, status = 200): Response =>
+	Response.json(body, { status, headers: { "cache-control": "no-store" } });