@pstdio/pocketcoder-remote 0.2.0 → 0.2.1

package/src/commands.ts

@@ -1,149 +0,0 @@
-import { randomUUID } from "node:crypto";
-import type { ControlPlaneClient, WorkspaceSummary } from "./control-plane";
-import { WorkspaceTerminalError } from "./control-plane";
-import { relayTarget, type TargetRef } from "./session-target";
-
-export interface CommandUi {
-	select(title: string, options: string[]): Promise<string | undefined>;
-	confirm(title: string, message: string): Promise<boolean>;
-	input(title: string, placeholder?: string): Promise<string | undefined>;
-	notify(message: string, type?: "info" | "warning" | "error"): void;
-	setWorkingMessage(message?: string): void;
-}
-
-export interface CommandContext {
-	hasUI: boolean;
-	ui: CommandUi;
-	newSession(): Promise<{ cancelled: boolean }>;
-}
-
-export interface CommandRegistrar {
-	registerCommand(
-		name: string,
-		options: {
-			description?: string;
-			handler: (args: string, ctx: CommandContext) => Promise<void>;
-		},
-	): void;
-}
-
-export interface WorkspaceCommandDeps {
-	targets: TargetRef;
-	controlPlane: ControlPlaneClient;
-	waitTimeoutMs?: number;
-}
-
-function workspaceLabel(workspace: WorkspaceSummary): string {
-	return `${workspace.external_id} · ${workspace.template.name} · ${workspace.id.slice(0, 8)}`;
-}
-
-async function switchToWorkspace(
-	deps: WorkspaceCommandDeps,
-	ctx: CommandContext,
-	workspaceId: string,
-): Promise<void> {
-	const target = deps.targets.current;
-	if (target.mode === "direct") return;
-	deps.targets.set(relayTarget(target.baseUrl, target.key, workspaceId));
-	await ctx.newSession();
-}
-
-function requireRelayCapable(deps: WorkspaceCommandDeps, ctx: CommandContext): boolean {
-	if (!ctx.hasUI) return false;
-	if (deps.targets.current.mode === "direct") {
-		ctx.ui.notify(
-			"workspace commands need a PocketCoder server (POCKETCODER_URL), not a direct AgentAPI URL",
-			"warning",
-		);
-		return false;
-	}
-	return true;
-}
-
-async function pickWorkspace(deps: WorkspaceCommandDeps, ctx: CommandContext): Promise<void> {
-	const workspaces = (await deps.controlPlane.workspaces.list({ state: "ready" })).items;
-	if (workspaces.length === 0) {
-		ctx.ui.notify("no ready workspaces; use /workspace-create", "info");
-		return;
-	}
-	const labels = workspaces.map(workspaceLabel);
-	const selection = await ctx.ui.select("Switch workspace", labels);
-	if (selection === undefined) return;
-	const workspace = workspaces[labels.indexOf(selection)];
-	if (workspace) await switchToWorkspace(deps, ctx, workspace.id);
-}
-
-async function createWorkspace(deps: WorkspaceCommandDeps, ctx: CommandContext): Promise<void> {
-	const templates = await deps.controlPlane.templates.list();
-	if (templates.length === 0) {
-		ctx.ui.notify("no templates available to this key", "warning");
-		return;
-	}
-	const labels = templates.map((template) => `${template.name}@${template.version}`);
-	const selection = await ctx.ui.select("Create workspace from template", labels);
-	if (selection === undefined) return;
-	const template = templates[labels.indexOf(selection)];
-	if (!template) return;
-	const externalId =
-		(await ctx.ui.input("External id", `pi-${randomUUID()}`))?.trim() || `pi-${randomUUID()}`;
-
-	try {
-		ctx.ui.setWorkingMessage(`creating workspace ${externalId}`);
-		const created = await deps.controlPlane.workspaces.create({
-			externalId,
-			templateName: template.name,
-		});
-		const ready = await deps.controlPlane.workspaces.waitForReady(
-			created,
-			deps.waitTimeoutMs ?? 300_000,
-			{
-				onTick: (workspace) => ctx.ui.setWorkingMessage(`workspace ${workspace.state}`),
-			},
-		);
-		await switchToWorkspace(deps, ctx, ready.id);
-	} catch (error) {
-		const message =
-			error instanceof WorkspaceTerminalError
-				? error.message
-				: `workspace create failed: ${String(error)}`;
-		ctx.ui.notify(message, "error");
-	} finally {
-		ctx.ui.setWorkingMessage();
-	}
-}
-
-async function cancelWorkspace(deps: WorkspaceCommandDeps, ctx: CommandContext): Promise<void> {
-	const target = deps.targets.current;
-	if (target.mode !== "relay") {
-		ctx.ui.notify("no workspace attached", "info");
-		return;
-	}
-	const confirmed = await ctx.ui.confirm(
-		"Cancel workspace",
-		`Cancel workspace ${target.workspaceId}? The remote agent stops and the workspace is discarded.`,
-	);
-	if (!confirmed) return;
-	await deps.controlPlane.workspaces.cancel(target.workspaceId);
-	ctx.ui.notify(`workspace ${target.workspaceId.slice(0, 8)} canceled`, "info");
-}
-
-export function registerWorkspaceCommands(pi: CommandRegistrar, deps: WorkspaceCommandDeps): void {
-	pi.registerCommand("workspace", {
-		description: "Switch to another ready PocketCoder workspace",
-		handler: async (_args, ctx) => {
-			if (requireRelayCapable(deps, ctx)) await pickWorkspace(deps, ctx);
-		},
-	});
-	pi.registerCommand("workspace-create", {
-		description: "Create a PocketCoder workspace from a template and switch to it",
-		handler: async (_args, ctx) => {
-			if (requireRelayCapable(deps, ctx)) await createWorkspace(deps, ctx);
-		},
-	});
-	pi.registerCommand("workspace-cancel", {
-		description: "Cancel the current PocketCoder workspace",
-		handler: async (_args, ctx) => {
-			if (requireRelayCapable(deps, ctx)) await cancelWorkspace(deps, ctx);
-		},
-	});
-}

package/src/control-plane.ts

@@ -1,30 +0,0 @@
-import {
-	ConversationGoneError,
-	type ConversationMessage,
-	PocketCoderClient,
-	PocketCoderError,
-	TERMINAL_WORKSPACE_STATES,
-	type WorkspaceSummary,
-	WorkspaceTerminalError,
-} from "@pstdio/pocketcoder-client";
-
-export {
-	ConversationGoneError,
-	type ConversationMessage,
-	PocketCoderError as ControlPlaneError,
-	TERMINAL_WORKSPACE_STATES,
-	type WorkspaceSummary,
-	WorkspaceTerminalError,
-};
-
-export interface ControlPlaneConfig {
-	baseUrl: string;
-	key: string;
-}
-
-/** @internal The remote UI keeps its historical config vocabulary at its boundary. */
-export class ControlPlaneClient extends PocketCoderClient {
-	constructor(config: ControlPlaneConfig, fetchImpl: typeof fetch = fetch) {
-		super({ baseUrl: config.baseUrl, apiKey: config.key }, fetchImpl);
-	}
-}

package/src/environment.ts

@@ -1,19 +0,0 @@
-export function serviceUrlFromEnvironment(env: NodeJS.ProcessEnv = process.env): {
-	serviceUrl: string;
-	key: string;
-} {
-	const directUrl = env.POCKETCODER_AGENTAPI_URL;
-	const key = env.POCKETCODER_KEY;
-	if (!key) throw new Error("POCKETCODER_KEY is required");
-	if (directUrl) return { serviceUrl: directUrl, key };
-
-	const baseUrl = (env.POCKETCODER_URL ?? "http://127.0.0.1:7080").replace(/\/$/, "");
-	const workspaceId = env.POCKETCODER_WORKSPACE_ID;
-	if (!workspaceId) {
-		throw new Error("POCKETCODER_WORKSPACE_ID or POCKETCODER_AGENTAPI_URL is required");
-	}
-	return {
-		serviceUrl: `${baseUrl}/v1/workspaces/${encodeURIComponent(workspaceId)}/agent`,
-		key,
-	};
-}

package/src/extension.ts

@@ -1,200 +0,0 @@
-import {
-	type Api,
-	type AssistantMessage,
-	type AssistantMessageEventStream,
-	type Context,
-	createAssistantMessageEventStream,
-	type Model,
-} from "@earendil-works/pi-ai";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import {
-	collectTurnFiles,
-	DIRECT_MODE_ATTACHMENT_ERROR,
-	registerAttachCommand,
-	uploadTurnFiles,
-	userTextOf,
-} from "./attachments";
-import { RemoteAgentClient } from "./client";
-import { registerWorkspaceCommands } from "./commands";
-import { ControlPlaneClient } from "./control-plane";
-import { replayHistory } from "./history";
-import { registerConversationRenderers } from "./renderers";
-import { emitRemoteResponse } from "./response-stream";
-import { relayTarget, TargetRef, targetFromEnvironment } from "./session-target";
-import { STATUS_KEY, StatusPoller } from "./status";
-
-const PROVIDER = "pocketcoder-agentapi";
-const MODEL = "remote-agent";
-
-function emptyUsage(): AssistantMessage["usage"] {
-	return {
-		input: 0,
-		output: 0,
-		cacheRead: 0,
-		cacheWrite: 0,
-		totalTokens: 0,
-		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-	};
-}
-
-function remoteStream(
-	targets: TargetRef,
-	controlPlane: ControlPlaneClient | undefined,
-	attachmentQueue: string[],
-	model: Model<Api>,
-	context: Context,
-	signal?: AbortSignal,
-	onOutputStart?: () => void,
-): AssistantMessageEventStream {
-	const stream = createAssistantMessageEventStream();
-	const output: AssistantMessage = {
-		role: "assistant",
-		content: [],
-		api: model.api,
-		provider: model.provider,
-		model: model.id,
-		usage: emptyUsage(),
-		stopReason: "pending",
-		timestamp: Date.now(),
-	};
-
-	void (async () => {
-		stream.push({ type: "start", partial: output });
-		try {
-			const target = targets.current;
-			if (target.mode === "unset") {
-				throw new Error("no workspace attached; run /workspace or /workspace-create first");
-			}
-			const files = collectTurnFiles(context, attachmentQueue);
-			if (files.length > 0 && (target.mode !== "relay" || !controlPlane)) {
-				throw new Error(DIRECT_MODE_ATTACHMENT_ERROR);
-			}
-			let attachmentIds: string[] = [];
-			if (files.length > 0 && target.mode === "relay" && controlPlane) {
-				attachmentIds = await uploadTurnFiles(controlPlane, target.workspaceId, files);
-				attachmentQueue.length = 0;
-			}
-			const client = new RemoteAgentClient({ serviceUrl: target.serviceUrl, key: target.key });
-			await emitRemoteResponse(
-				stream,
-				output,
-				async (onSnapshot) =>
-					await client.send(userTextOf(context), signal, attachmentIds, onSnapshot),
-				onOutputStart,
-			);
-		} catch (error) {
-			output.stopReason = signal?.aborted ? "aborted" : "error";
-			output.errorMessage = error instanceof Error ? error.message : String(error);
-			stream.push({ type: "error", reason: output.stopReason, error: output });
-		} finally {
-			stream.end();
-		}
-	})();
-
-	return stream;
-}
-
-async function pickInitialWorkspace(
-	controlPlane: ControlPlaneClient,
-	targets: TargetRef,
-	context: ExtensionContext,
-): Promise<void> {
-	const target = targets.current;
-	if (target.mode !== "unset" || !context.hasUI) return;
-	const workspaces = (await controlPlane.workspaces.list({ state: "ready" })).items;
-	if (workspaces.length === 0) {
-		context.ui.notify("no ready workspaces; run /workspace-create", "warning");
-		return;
-	}
-	const labels = workspaces.map(
-		(workspace) =>
-			`${workspace.external_id} · ${workspace.template.name} · ${workspace.id.slice(0, 8)}`,
-	);
-	const selection = await context.ui.select("Attach to workspace", labels);
-	if (selection === undefined) {
-		context.ui.notify("no workspace attached; run /workspace to attach", "warning");
-		return;
-	}
-	const workspace = workspaces[labels.indexOf(selection)];
-	if (workspace) targets.set(relayTarget(target.baseUrl, target.key, workspace.id));
-}
-
-export default function (pi: ExtensionAPI): void {
-	const targets = new TargetRef(targetFromEnvironment());
-	const initial = targets.current;
-	const controlPlane =
-		initial.mode === "direct"
-			? undefined
-			: new ControlPlaneClient({ baseUrl: initial.baseUrl, key: initial.key });
-	const attachmentQueue: string[] = [];
-	let poller: StatusPoller | undefined;
-	let activeContext: ExtensionContext | undefined;
-
-	pi.registerProvider(PROVIDER, {
-		name: "PocketCoder remote agent",
-		baseUrl: initial.mode === "direct" ? initial.serviceUrl : initial.baseUrl,
-		apiKey: "local-ui",
-		api: "openai-completions",
-		models: [
-			{
-				id: MODEL,
-				name: "PocketCoder remote agent",
-				reasoning: false,
-				input: ["text", "image"],
-				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-				contextWindow: 1_000_000,
-				maxTokens: 100_000,
-			},
-		],
-		streamSimple: (model, context, options) =>
-			remoteStream(targets, controlPlane, attachmentQueue, model, context, options?.signal, () =>
-				activeContext?.ui.setWorkingVisible(false),
-			),
-	});
-
-	registerConversationRenderers(pi);
-	registerAttachCommand(pi, { targets, queue: attachmentQueue });
-	if (controlPlane) registerWorkspaceCommands(pi, { targets, controlPlane });
-
-	pi.on("session_start", async (_event, context) => {
-		activeContext = context;
-		pi.setActiveTools([]);
-		await poller?.stop();
-		poller = undefined;
-
-		if (controlPlane) await pickInitialWorkspace(controlPlane, targets, context);
-		const target = targets.current;
-		if (target.mode === "direct") {
-			context.ui.setStatus(STATUS_KEY, "direct agentapi");
-			return;
-		}
-		if (target.mode === "unset") {
-			context.ui.setStatus(STATUS_KEY, "no workspace");
-			return;
-		}
-		context.ui.setStatus(STATUS_KEY, `ws ${target.workspaceId.slice(0, 8)}`);
-		if (!controlPlane) return;
-		try {
-			const workspace = await controlPlane.workspaces.get(target.workspaceId);
-			await replayHistory(pi, controlPlane, target.workspaceId);
-			poller = new StatusPoller(controlPlane, workspace, context.ui);
-			poller.start();
-		} catch (error) {
-			context.ui.notify(
-				`could not load workspace history: ${error instanceof Error ? error.message : String(error)}`,
-				"warning",
-			);
-		}
-	});
-
-	pi.on("turn_start", async () => poller?.pause());
-	pi.on("turn_end", async (_event, context) => {
-		context.ui.setWorkingVisible(true);
-		poller?.resume();
-	});
-	pi.on("session_shutdown", async () => {
-		await poller?.stop();
-		poller = undefined;
-		activeContext = undefined;
-	});
-}

package/src/history.ts

@@ -1,112 +0,0 @@
-import type { ControlPlaneClient } from "./control-plane";
-import { ConversationGoneError } from "./control-plane";
-import {
-	type ConversationEntryData,
-	HISTORY_ENTRY_TYPE,
-	type HistoryNoticeData,
-	NOTICE_ENTRY_TYPE,
-} from "./renderers";
-
-export interface ReplayOptions {
-	pageLimit?: number;
-	maxMessages?: number;
-	maxPages?: number;
-}
-
-export interface ReplayOutcome {
-	replayed: number;
-	total: number;
-	truncated: boolean;
-	gone: boolean;
-}
-
-export interface EntrySink {
-	appendEntry<T = unknown>(customType: string, data?: T): void;
-}
-
-/**
- * Replays the workspace's durable conversation into the local session as
- * custom entries. The server transcript is the source of truth: this runs on
- * every attach, and entries never participate in LLM context.
- */
-interface TranscriptTail {
-	tail: ConversationEntryData[];
-	total: number;
-	pages: number;
-	exhaustedPages: boolean;
-}
-
-async function collectTranscriptTail(
-	controlPlane: ControlPlaneClient,
-	workspaceId: string,
-	options: Required<ReplayOptions>,
-): Promise<TranscriptTail> {
-	const tail: ConversationEntryData[] = [];
-	let total = 0;
-	let pages = 0;
-	let cursor: string | undefined;
-	while (pages < options.maxPages) {
-		const page = await controlPlane.conversations.list(workspaceId, {
-			cursor,
-			limit: options.pageLimit,
-		});
-		pages += 1;
-		for (const message of page.items) {
-			total += 1;
-			tail.push({
-				role: message.role,
-				content: message.content,
-				seq: message.seq,
-				occurred_at: message.occurred_at,
-				kind: message.metadata?.kind,
-				metadata: message.metadata,
-			});
-			if (tail.length > options.maxMessages) tail.shift();
-		}
-		if (page.nextCursor === null) return { tail, total, pages, exhaustedPages: false };
-		cursor = page.nextCursor;
-	}
-	return { tail, total, pages, exhaustedPages: true };
-}
-
-export async function replayHistory(
-	pi: EntrySink,
-	controlPlane: ControlPlaneClient,
-	workspaceId: string,
-	options: ReplayOptions = {},
-): Promise<ReplayOutcome> {
-	let transcript: TranscriptTail;
-	try {
-		transcript = await collectTranscriptTail(controlPlane, workspaceId, {
-			pageLimit: options.pageLimit ?? 200,
-			maxMessages: options.maxMessages ?? 1000,
-			maxPages: options.maxPages ?? 50,
-		});
-	} catch (error) {
-		if (error instanceof ConversationGoneError) {
-			pi.appendEntry<HistoryNoticeData>(NOTICE_ENTRY_TYPE, {
-				text:
-					error.code === "conversation.deleted"
-						? "conversation history was deleted"
-						: "conversation history has expired",
-				level: "warning",
-			});
-			return { replayed: 0, total: 0, truncated: false, gone: true };
-		}
-		throw error;
-	}
-
-	const { tail, total, pages, exhaustedPages } = transcript;
-	const truncated = total > tail.length || exhaustedPages;
-	if (truncated) {
-		pi.appendEntry<HistoryNoticeData>(NOTICE_ENTRY_TYPE, {
-			text: exhaustedPages
-				? `history partially replayed (stopped after ${pages} pages)`
-				: `showing last ${tail.length} of ${total} messages`,
-		});
-	}
-	for (const message of tail) {
-		pi.appendEntry<ConversationEntryData>(HISTORY_ENTRY_TYPE, message);
-	}
-	return { replayed: tail.length, total, truncated, gone: false };
-}

package/src/launch.ts

@@ -1,85 +0,0 @@
-import { readFileSync } from "node:fs";
-import { dirname, resolve, sep } from "node:path";
-import { fileURLToPath } from "node:url";
-
-export interface PiInvocation {
-	command: string;
-	args: string[];
-	env: NodeJS.ProcessEnv;
-}
-
-export interface ResolveOptions {
-	env?: NodeJS.ProcessEnv;
-	argv?: string[];
-	execPath?: string;
-	resolvePath?: (specifier: string) => string;
-}
-
-const PI_FLAGS = [
-	"--provider",
-	"pocketcoder-agentapi",
-	"--model",
-	"remote-agent",
-	"--api-key",
-	"local-ui",
-	"--no-tools",
-	"--no-extensions",
-	"--no-skills",
-	"--no-context-files",
-	"--no-prompt-templates",
-	"--no-session",
-	"--offline",
-];
-
-function piBinPath(resolvePath: (specifier: string) => string): string {
-	// The package's exports map hides ./package.json, so locate the package
-	// root from its resolved main entry instead.
-	const entry = resolvePath("@earendil-works/pi-coding-agent");
-	const marker = `${sep}pi-coding-agent${sep}`;
-	const index = entry.lastIndexOf(marker);
-	if (index === -1) {
-		throw new Error(`could not locate @earendil-works/pi-coding-agent from ${entry}`);
-	}
-	const packageRoot = entry.slice(0, index + marker.length - 1);
-	const manifest = JSON.parse(readFileSync(resolve(packageRoot, "package.json"), "utf8")) as {
-		bin?: Record<string, string>;
-	};
-	const bin = manifest.bin?.pi;
-	if (!bin) throw new Error("@earendil-works/pi-coding-agent does not declare a pi bin");
-	return resolve(packageRoot, bin);
-}
-
-function extensionPath(): string {
-	// Works from both src/bin.ts (dev) and dist/bin.js (published): the
-	// package root is one directory up in both layouts.
-	const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-	return resolve(packageRoot, "src/extension.ts");
-}
-
-export function resolvePiInvocation(options: ResolveOptions = {}): PiInvocation {
-	const env = options.env ?? process.env;
-	if (!env.POCKETCODER_KEY) {
-		throw new Error(
-			"POCKETCODER_KEY is required. Issue a machine key with `pcd keys issue` and export it, along with POCKETCODER_URL for your PocketCoder server.",
-		);
-	}
-	// The pi package's exports map only defines the "import" condition, so
-	// resolution must go through ESM resolve, not createRequire.
-	const resolvePath =
-		options.resolvePath ?? ((specifier: string) => fileURLToPath(import.meta.resolve(specifier)));
-	const childEnv: NodeJS.ProcessEnv = { ...env };
-	// Pi must never talk to a model provider directly; every turn goes
-	// through the PocketCoder relay.
-	delete childEnv.OPENAI_API_KEY;
-	return {
-		command: options.execPath ?? process.execPath,
-		args: [
-			piBinPath(resolvePath),
-			...PI_FLAGS,
-			"--extension",
-			extensionPath(),
-			...(options.argv ?? []),
-		],
-		env: childEnv,
-	};
-}

package/src/renderers.ts

@@ -1,76 +0,0 @@
-import type { ExtensionAPI, ThemeColor } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import { splitAttachmentManifest } from "@pstdio/pocketcoder-client";
-
-export const HISTORY_ENTRY_TYPE = "pocketcoder-conversation";
-export const NOTICE_ENTRY_TYPE = "pocketcoder-history-notice";
-
-export interface ConversationEntryData {
-	role: string;
-	content: string;
-	seq: number;
-	occurred_at: string;
-	/** Reserved for future typed payloads (tool_use, permission_request, ...). */
-	kind?: string;
-	metadata?: Record<string, string>;
-}
-
-export interface HistoryNoticeData {
-	text: string;
-	level?: "info" | "warning";
-}
-
-/** The slice of Pi's Theme the formatters use; Theme satisfies it structurally. */
-export interface ThemeLike {
-	fg(color: ThemeColor, text: string): string;
-	bold(text: string): string;
-}
-
-function roleHeader(data: ConversationEntryData, theme: ThemeLike): string {
-	const time = data.occurred_at.replace("T", " ").replace(/\.\d+Z?$|Z$/, "");
-	return theme.fg("muted", `${data.role} · ${time}`);
-}
-
-// User messages may end in the generated attachment manifest; history shows
-// the attachment names instead of the raw markup and managed paths.
-function userBody(content: string, theme: ThemeLike): string {
-	const { text, attachments } = splitAttachmentManifest(content);
-	const body = theme.fg("userMessageText", text);
-	if (!attachments) return body;
-	const list = attachments
-		.map((attachment) => theme.fg("muted", `⌁ ${attachment.name} (${attachment.size_bytes} bytes)`))
-		.join("\n");
-	return `${body}\n${list}`;
-}
-
-export function formatConversationMessage(data: ConversationEntryData, theme: ThemeLike): string {
-	switch (data.kind ?? "text") {
-		// Future typed kinds (tool_use, permission_request, ...) become new cases;
-		// unknown kinds deliberately fall through to the text rendering.
-		default: {
-			const header = roleHeader(data, theme);
-			const body =
-				data.role === "user"
-					? userBody(data.content, theme)
-					: data.role === "assistant"
-						? data.content
-						: theme.fg("dim", data.content);
-			return `${header}\n${body}`;
-		}
-	}
-}
-
-export function formatHistoryNotice(data: HistoryNoticeData, theme: ThemeLike): string {
-	return theme.fg(data.level === "warning" ? "warning" : "muted", data.text);
-}
-
-export function registerConversationRenderers(pi: ExtensionAPI): void {
-	pi.registerEntryRenderer<ConversationEntryData>(HISTORY_ENTRY_TYPE, (entry, _options, theme) => {
-		if (!entry.data) return undefined;
-		return new Text(formatConversationMessage(entry.data, theme), 1, 0);
-	});
-	pi.registerEntryRenderer<HistoryNoticeData>(NOTICE_ENTRY_TYPE, (entry, _options, theme) => {
-		if (!entry.data) return undefined;
-		return new Text(formatHistoryNotice(entry.data, theme), 1, 0);
-	});
-}