Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/activity/ui.ts

Raw
import type {
	ExtensionCommandContext,
	Theme,
} from "@earendil-works/pi-coding-agent";
import {
	type Component,
	CURSOR_MARKER,
	decodeKittyPrintable,
	type Focusable,
	isKeyRelease,
	type KeybindingsManager,
	matchesKey,
	parseKey,
	renderFakeCursor,
	type SelectItem,
	SelectList,
	sliceByColumn,
	stripTerminalSequences,
	type TUI,
	type TuiMouseEvent,
	truncateToWidth,
	visibleWidth,
} from "@earendil-works/pi-tui";
import type { ActivityManager } from "./runtime.js";
import type { ActivitySnapshot, TimerView } from "./types.js";
import type { TerminalView } from "./view.js";

type ManagerApi = Pick<
	ActivityManager,
	| "list"
	| "read"
	| "attention"
	| "acknowledge"
	| "write"
	| "resize"
	| "subscribe"
	| "terminalView"
	| "timerView"
	| "stop"
>;

type TerminalInput =
	| { detach: true }
	| { text: string; paste?: true }
	| undefined;

const OUTPUT_LIMIT = 16_384;
const OUTPUT_LINES = 48;
const EVENT_LINES = 8;
const REFRESH_MS = 100;
const MIN_COLS = 20;
const MAX_COLS = 200;
const MIN_ROWS = 5;
const MAX_ROWS = 60;

export async function openActivities(
	manager: ManagerApi,
	ctx: ExtensionCommandContext,
	id?: string,
): Promise<void> {
	if (ctx.mode !== "tui") {
		if (ctx.hasUI)
			ctx.ui.notify("Activities require Pi's terminal UI.", "warning");
		return;
	}

	const api: ManagerApi = manager;
	let selectedId = id;
	let previousId: string | undefined;
	try {
		while (true) {
			if (!selectedId) {
				if (api.list().length === 0) {
					ctx.ui.notify("No activities.", "info");
					return;
				}
				selectedId = await ctx.ui.custom<string | undefined>(
					(tui, theme, _keybindings, done) =>
						activityPicker(api, tui, theme, done, previousId),
					{
						overlay: true,
						blocked: { kind: "question", message: "Choose an activity" },
						overlayOptions: { anchor: "center", width: 68, maxHeight: "90%" },
					},
				);
			}
			if (!selectedId) return;
			const inspectedId = selectedId;
			const activity = api.read(inspectedId);
			await ctx.ui.custom<void>(
				(tui, theme, keybindings, done) =>
					new ActivityInspector(
						tui,
						theme,
						keybindings,
						done,
						api,
						inspectedId,
						!id,
					),
				{
					overlay: true,
					blocked: { kind: "question", message: "Inspect activity" },
					overlayOptions: {
						anchor: "center",
						width: activity.kind === "terminal" ? "90%" : 68,
						maxHeight: "90%",
					},
				},
			);
			if (id) return;
			previousId = inspectedId;
			selectedId = undefined;
		}
	} catch (error) {
		ctx.ui.notify(`Activities unavailable: ${errorMessage(error)}`, "error");
	}
}

const KINDS = {
	process: { icon: "⚙", label: "Process", running: "Running" },
	terminal: { icon: "▣", label: "Terminal", running: "Open" },
	watch: { icon: "◎", label: "Watch", running: "Watching" },
	timer: { icon: "◷", label: "Timer", running: "Waiting" },
} as const;
const STATES = {
	running: { icon: "●", label: "Running" },
	stopping: { icon: "◌", label: "Stopping…" },
	completed: { icon: "✓", label: "Done" },
	failed: { icon: "✕", label: "Failed" },
	stopped: { icon: "■", label: "Stopped" },
} as const;
const RESET = "\x1b[0m";
const WIDGET_ICON = "\u{F0996}"; // nf-md-progress_clock

function isActive(activity: ActivitySnapshot): boolean {
	return activity.status === "running" || activity.status === "stopping";
}

function statusLabel(activity: ActivitySnapshot): string {
	return activity.status === "running"
		? KINDS[activity.kind].running
		: STATES[activity.status].label;
}

/** Compact, non-focusable status using the same labels as the inspector. */
export function activityWidget(
	activities: ActivitySnapshot[],
	theme: Theme,
): Component {
	const active = activities.filter(isActive).length;
	const failed = activities.filter(
		(activity) => activity.status === "failed",
	).length;
	const priority = {
		stopping: 0,
		running: 1,
		failed: 2,
		completed: 3,
		stopped: 4,
	};
	const sorted = [...activities].sort(
		(a, b) =>
			priority[a.status] - priority[b.status] || b.createdAt - a.createdAt,
	);
	const shown = active
		? sorted.filter(isActive).slice(0, 3)
		: sorted.slice(0, 1);
	const failure = active
		? sorted.find((activity) => activity.status === "failed")
		: undefined;
	if (failure) shown.push(failure);
	const more = activities.length - shown.length;
	return {
		render(width) {
			if (width < 1 || !activities.length) return [];
			const parts: string[] = [];
			if (active) parts.push(`${active} active`);
			if (failed) parts.push(`${failed} failed`);
			if (more) parts.push(`${more} hidden`);
			const icon = theme.fg(
				failed ? "error" : active ? "accent" : "muted",
				` ${WIDGET_ICON} `,
			);
			const headingWidth = Math.max(0, width - visibleWidth(icon));
			const full = ["Activities", ...parts].join(" · ");
			const heading =
				visibleWidth(full) <= headingWidth || !parts.length
					? full
					: parts.join(" ");
			const header = icon + theme.fg("accent", heading);
			return [
				header,
				...shown.map((activity) => {
					const state = theme.fg(
						statusColor(activity),
						`${STATES[activity.status].icon} ${statusLabel(activity)}`,
					);
					const title = singleLine(sanitizeActivityText(activity.title));
					const exit =
						activity.status === "failed" && activity.exitCode != null
							? ` · exit ${activity.exitCode}`
							: "";
					const prefix = `   ${state} · `;
					const suffix = theme.fg(
						"text",
						` · ${KINDS[activity.kind].label}${exit}`,
					);
					const available = Math.max(
						0,
						width - visibleWidth(prefix) - visibleWidth(suffix),
					);
					const titleWidth = visibleWidth(title);
					const tail = Math.floor((available - 1) / 3);
					const compact =
						titleWidth > available && tail > 0
							? `${sliceByColumn(title, 0, available - tail - 1, true)}…${sliceByColumn(title, titleWidth - tail, tail, true)}`
							: truncateToWidth(title, available, "…");
					return prefix + compact + suffix;
				}),
			].map((line) => truncateToWidth(line, width));
		},
		invalidate() {},
	};
}

export function formatActivityOption(
	activity: ActivitySnapshot,
	hidden = false,
): SelectItem {
	return {
		value: activity.id,
		label: `${STATES[activity.status].icon} ${KINDS[activity.kind].icon} ${singleLine(sanitizeActivityText(activity.title))}`,
		description: `${statusLabel(activity)}${hidden ? " · hidden" : ""}`,
	};
}

export function activityPicker(
	manager: Pick<
		ManagerApi,
		"list" | "attention" | "subscribe" | "stop" | "acknowledge"
	>,
	tui: TUI,
	theme: Theme,
	done: (id: string | undefined) => void,
	selectedId?: string,
): Component & { dispose(): void } {
	const items = manager
		.list()
		.slice()
		.sort(
			(a, b) =>
				Number(isActive(b)) - Number(isActive(a)) || b.createdAt - a.createdAt,
		)
		.map(formatActivityOption);
	let list: SelectList;
	let visibleRows = 0;
	let listHeight = 0;
	let stopFailed = false;
	const updateSize = () => {
		const rows = Math.max(
			1,
			Math.min(8, Math.floor(tui.terminal.rows * 0.9) - 6),
		);
		if (rows === visibleRows) return;
		const selected = list?.getSelectedItem()?.value ?? selectedId;
		list = new SelectList(items, rows, {
			selectedPrefix: (text) => theme.fg("accent", text),
			selectedText: (text) => theme.fg("accent", theme.bold(text)),
			description: (text) => theme.fg("muted", text),
			scrollInfo: (text) => theme.fg("dim", text),
			noMatch: (text) => theme.fg("muted", text),
		});
		list.setSelectedIndex(
			Math.max(
				0,
				items.findIndex((item) => item.value === selected),
			),
		);
		list.onSelect = (item) => {
			if (manager.list().some((activity) => activity.id === item.value))
				done(item.value);
		};
		list.onCancel = () => done(undefined);
		visibleRows = rows;
	};
	updateSize();
	const unsubscribe = manager.subscribe(() => tui.requestRender());
	return {
		render(width) {
			// Keep row identities/order stable during mouse gestures; refresh presentation only.
			const current = new Map(
				manager.list().map((activity) => [activity.id, activity]),
			);
			const pinned = new Set(manager.attention().map(({ id }) => id));
			for (const item of items) {
				const activity = current.get(item.value);
				if (activity)
					Object.assign(
						item,
						formatActivityOption(
							activity,
							activity.status === "failed" && !pinned.has(activity.id),
						),
					);
				else {
					item.label = "○ No longer available";
					item.description = "";
				}
			}
			updateSize();
			const lines = list.render(Math.max(1, width - 4));
			listHeight = lines.length;
			return renderPanel(
				"Activities",
				[
					"",
					...lines.map((line) => ` ${line}`),
					"",
					` ${theme.fg(stopFailed ? "error" : "text", stopFailed ? "Stop failed; inspect activity for details." : "↑↓ · Enter inspect · x stop · d hide · D hide all · Esc close")}`,
				],
				width,
				theme,
			);
		},
		dispose: unsubscribe,
		invalidate() {
			list.invalidate();
		},
		handleInput(data) {
			if (data === "x") {
				const id = list.getSelectedItem()?.value;
				const activity = manager.list().find((item) => item.id === id);
				if (activity && isActive(activity)) {
					stopFailed = false;
					void manager.stop(activity.id).catch(() => {
						stopFailed = true;
						tui.requestRender();
					});
				}
			} else if (data === "d") {
				const id = list.getSelectedItem()?.value;
				if (id) manager.acknowledge(id);
			} else if (data === "D") {
				for (const activity of manager.list())
					if (!isActive(activity)) manager.acknowledge(activity.id);
			} else list.handleInput(data);
			tui.requestRender();
		},
		handleMouse(event: TuiMouseEvent) {
			if (
				event.x < 2 ||
				event.x >= event.width - 2 ||
				event.y < 2 ||
				event.y >= listHeight + 2
			)
				return undefined;
			return list.handleMouse({
				...event,
				x: event.x - 2,
				y: event.y - 2,
				width: Math.max(1, event.width - 4),
				height: listHeight,
			});
		},
	};
}

/** Remove terminal controls before rendering activity-owned text in Pi's TUI. */
export function sanitizeActivityText(text: string): string {
	return stripTerminalSequences(text)
		.replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, "�")
		.slice(-OUTPUT_LIMIT);
}

/** Translate Pi's normalized keyboard input to conservative terminal application bytes. */
export function terminalInput(data: string): TerminalInput {
	if (isKeyRelease(data)) return undefined;
	if (data.startsWith("\x1b[200~") && data.endsWith("\x1b[201~"))
		return { text: data.slice(6, -6), paste: true };
	if (matchesKey(data, "ctrl+g")) return { detach: true };
	// Preserve legacy control/Meta bytes instead of Pi editor aliases (e.g. Alt+B → Alt+Left).
	if (
		/^[\x00-\x1f\x7f]$/.test(data) ||
		/^\x1b[^\x00-\x1f\x7f-\x9f]$/u.test(data)
	)
		return { text: data };
	const key = parseKey(data);
	if (key) {
		const mapped = TERMINAL_KEYS[key];
		if (mapped !== undefined) return { text: mapped };
		const modifiers = key.split("+");
		const base = modifiers.pop() ?? "";
		const modifier =
			1 +
			(modifiers.includes("shift") ? 1 : 0) +
			(modifiers.includes("alt") ? 2 : 0) +
			(modifiers.includes("ctrl") ? 4 : 0);
		const sequence = TERMINAL_KEYS[base];
		if (modifier > 1 && sequence?.startsWith("\x1b[")) {
			const navigation = /^\x1b\[([ABCDHF])$/.exec(sequence);
			if (navigation) return { text: `\x1b[1;${modifier}${navigation[1]}` };
			const editing = /^\x1b\[(\d+)~$/.exec(sequence);
			if (editing) return { text: `\x1b[${editing[1]};${modifier}~` };
		}
		if (modifier > 1 && sequence?.startsWith("\x1bO"))
			return { text: `\x1b[1;${modifier}${sequence.at(-1)}` };
		const control = modifiers.includes("ctrl")
			? (CONTROL_KEYS[base] ??
				(/^[a-z]$/i.test(base)
					? String.fromCharCode(base.toLowerCase().charCodeAt(0) - 96)
					: undefined))
			: undefined;
		const text =
			control ??
			sequence ??
			decodeKittyPrintable(data) ??
			(base.length === 1 ? base : undefined);
		if (text !== undefined)
			return { text: (modifiers.includes("alt") ? "\x1b" : "") + text };
	}
	// Pi's keybinding parser need not name every standard modified function key.
	if (/^\x1b\[(?:1;[2-8][PQRS]|(?:15|17|18|19|20|21|23|24);[2-8]~)$/.test(data))
		return { text: data };
	const printable = decodeKittyPrintable(data);
	if (printable !== undefined) return { text: printable };
	return /^[^\u0000-\u001f\u007f\u001b]+$/u.test(data)
		? { text: data }
		: undefined;
}

const CONTROL_KEYS: Record<string, string> = {
	space: "\x00",
	"@": "\x00",
	"[": "\x1b",
	"\\": "\x1c",
	"]": "\x1d",
	"^": "\x1e",
	_: "\x1f",
	"?": "\x7f",
};

const TERMINAL_KEYS: Record<string, string> = {
	escape: "\u001b",
	enter: "\r",
	return: "\r",
	backspace: "\u007f",
	delete: "\u001b[3~",
	insert: "\u001b[2~",
	f1: "\x1bOP",
	f2: "\x1bOQ",
	f3: "\x1bOR",
	f4: "\x1bOS",
	f5: "\x1b[15~",
	f6: "\x1b[17~",
	f7: "\x1b[18~",
	f8: "\x1b[19~",
	f9: "\x1b[20~",
	f10: "\x1b[21~",
	f11: "\x1b[23~",
	f12: "\x1b[24~",
	up: "\u001b[A",
	down: "\u001b[B",
	right: "\u001b[C",
	left: "\u001b[D",
	home: "\u001b[H",
	end: "\u001b[F",
	pageUp: "\u001b[5~",
	pageDown: "\u001b[6~",
	tab: "\t",
	"shift+tab": "\u001b[Z",
	"ctrl+c": "\u0003",
};

function clipPanelText(text: string, width: number): string {
	if (width < 1) return "";
	return visibleWidth(text) > width
		? `${sliceByColumn(text, 0, width - 1, true)}…`
		: text;
}

function renderPanel(
	title: string,
	rows: string[],
	width: number,
	theme?: Theme,
	markClipping = true,
): string[] {
	const safeWidth = Math.max(1, width);
	if (safeWidth < 3) return [truncateToWidth(title, safeWidth, "")];
	const inner = safeWidth - 2;
	const background = theme?.getBgAnsi("customMessageBg") ?? "";
	const foreground = theme?.getFgAnsi("text") ?? "";
	const edgeStyle = theme?.getFgAnsi("border") ?? "";
	const edge = (text: string) => RESET + background + edgeStyle + text + RESET;
	const caption = clipPanelText(` ${title} `, inner);
	const heading = theme ? theme.fg("accent", theme.bold(caption)) : caption;
	return [
		edge("╭") +
			background +
			heading +
			edge("─".repeat(Math.max(0, inner - visibleWidth(caption))) + "╮"),
		...rows.map((text) => {
			const body = markClipping
				? clipPanelText(singleLine(text), inner)
				: truncateToWidth(singleLine(text), inner, "");
			return (
				edge("│") +
				background +
				foreground +
				body +
				RESET +
				background +
				" ".repeat(Math.max(0, inner - visibleWidth(body))) +
				edge("│")
			);
		}),
		edge(`╰${"─".repeat(inner)}╯`),
	];
}

function duration(milliseconds: number): string {
	const seconds = Math.max(0, Math.ceil(milliseconds / 1000));
	if (seconds < 60) return `${seconds}s`;
	if (seconds < 3600)
		return `${Math.floor(seconds / 60)}m${seconds % 60 ? ` ${seconds % 60}s` : ""}`;
	return `${Math.floor(seconds / 3600)}h${Math.floor((seconds % 3600) / 60) ? ` ${Math.floor((seconds % 3600) / 60)}m` : ""}`;
}

function timerLines(
	activity: ActivitySnapshot,
	timer: TimerView | undefined,
	theme?: Theme,
): string[] {
	if (!timer)
		return [isActive(activity) ? "Waiting for timer…" : "Timer finished"];
	if (activity.status !== "running")
		return [
			`${duration(timer.delayMs)} ${timer.repeat ? "between ticks" : "timer"}`,
		];
	const remaining = Math.max(0, timer.nextAt - Date.now());
	const filled = Math.round(
		20 * Math.max(0, Math.min(1, 1 - remaining / timer.delayMs)),
	);
	const progress = "━".repeat(filled);
	const rest = "─".repeat(20 - filled);
	return [
		`${duration(remaining)} ${timer.repeat ? "until next tick" : "remaining"}`,
		theme
			? theme.fg("accent", progress) + theme.fg("dim", rest)
			: progress + rest,
		...(timer.repeat ? [`Repeats every ${duration(timer.delayMs)}`] : []),
	];
}

export function renderActivityFrame(
	activity: ActivitySnapshot,
	width: number,
	maxRows = 64,
	{
		view,
		theme,
		timer,
		backToPicker = false,
		stopFailed = false,
	}: {
		view?: TerminalView;
		theme?: Theme;
		timer?: TimerView;
		backToPicker?: boolean;
		stopFailed?: boolean;
	} = {},
): string[] {
	const kind = KINDS[activity.kind];
	const title = `${kind.icon} ${singleLine(sanitizeActivityText(activity.title))}`;
	const endedAt = isActive(activity)
		? Date.now()
		: activity.events?.findLast(
				(event) => event.type === "exit" || event.type === "error",
			)?.time;
	const elapsed =
		(activity.kind === "process" || activity.kind === "terminal") &&
		endedAt !== undefined
			? ` · ${duration(Math.floor(Math.max(0, endedAt - activity.createdAt) / 1000) * 1000)} elapsed`
			: "";
	const meta = `${STATES[activity.status].icon} ${kind.label} · ${statusLabel(activity)}${activity.status === "failed" && activity.exitCode != null ? ` · exit ${activity.exitCode}` : ""}${elapsed}`;
	const error = stopFailed
		? "✕ Stop failed; retry x."
		: activity.error
			? `✕ ${sanitizeActivityText(activity.error)}`
			: view?.truncated
				? "View clipped; resize terminal"
				: "";
	const content =
		activity.kind === "terminal"
			? (view?.lines ?? terminalLines(activity, Math.max(1, width - 2)))
			: activity.kind === "timer"
				? timerLines(activity, timer, theme)
				: outputLines(activity);
	const hints =
		activity.kind === "terminal" && isActive(activity)
			? activity.status === "running"
				? ["Ctrl+G back · keys → app", "Stop: Ctrl+G → /activities → x"]
				: ["Ctrl+G back"]
			: [
					`${isActive(activity) ? "x stop · " : ""}${backToPicker ? "Esc back" : "Esc close"}`,
				];
	const availableRows = Math.max(1, maxRows - 4 - hints.length);
	const rowBudget =
		activity.kind === "terminal"
			? availableRows
			: Math.min(OUTPUT_LINES, availableRows);
	const omitted =
		activity.kind === "process" &&
		(activity.outputTruncated || content.length > rowBudget);
	const limit = Math.max(1, rowBudget - (omitted && error ? 1 : 0));
	const visible =
		activity.kind === "terminal"
			? content.slice(0, limit)
			: content.slice(-limit).map((line) => ` ${line}`);
	const notice = omitted
		? `Showing ${visible.length} lines · earlier omitted`
		: "";
	const details = error && notice ? [error, notice] : [error || notice];
	return renderPanel(
		title,
		[
			clipPanelText(
				` ${theme ? theme.fg(statusColor(activity), meta) : meta}`,
				width - 2,
			),
			...details.map((detail, index) =>
				clipPanelText(
					` ${theme && detail ? theme.fg(index === 0 && error ? (activity.error || stopFailed ? "error" : "warning") : "text", detail) : detail}`,
					width - 2,
				),
			),
			...visible,
			...hints.map((hint) =>
				clipPanelText(` ${theme ? theme.fg("text", hint) : hint}`, width - 2),
			),
		],
		width,
		theme,
		activity.kind !== "terminal",
	);
}

function singleLine(text: string): string {
	return text.replace(/[\r\n\t\u0080-\u009f]+/g, " ");
}

function outputLines(activity: ActivitySnapshot): string[] {
	if (activity.kind === "watch") {
		const changes = (activity.events ?? [])
			.filter((event) => event.type === "change")
			.slice(-EVENT_LINES);
		return changes.length
			? changes.map(
					(event) =>
						`↻ ${sanitizeActivityText(event.text ?? "Change detected")}`,
				)
			: [isActive(activity) ? "Watching for changes…" : "No changes recorded"];
	}
	const output = sanitizeActivityText(activity.output ?? "");
	return output
		? output.split("\n")
		: [isActive(activity) ? "Waiting for output…" : "No output"];
}

function terminalLines(activity: ActivitySnapshot, width: number): string[] {
	const screen = activity.screen;
	if (!screen) return ["(terminal screen unavailable)"];
	const lines = sanitizeActivityText(screen.text).split("\n");
	return lines
		.slice(-Math.min(MAX_ROWS, Math.max(MIN_ROWS, screen.rows)))
		.map((line) => sliceByColumn(line, 0, width, true));
}

export class ActivityInspector implements Component, Focusable {
	focused = false;
	private unsubscribe: (() => void) | undefined;
	private refreshTimer: ReturnType<typeof setTimeout> | undefined;
	private resizeTimer: ReturnType<typeof setTimeout> | undefined;
	private clockTimer: ReturnType<typeof setInterval> | undefined;
	private disposed = false;
	private renderedWidth = 0;
	private stopFailed = false;

	constructor(
		private readonly tui: TUI,
		private readonly theme: Theme,
		private readonly keybindings: KeybindingsManager,
		private readonly done: () => void,
		private readonly manager: ManagerApi,
		private readonly id: string,
		private readonly backToPicker = false,
	) {
		this.unsubscribe = manager.subscribe(() => this.scheduleRefresh());
		const activity = this.current();
		if (activity && isActive(activity) && activity.kind !== "watch") {
			this.clockTimer = setInterval(() => {
				const current = this.current();
				if (!current || !isActive(current)) {
					clearInterval(this.clockTimer);
					this.clockTimer = undefined;
				}
				this.scheduleRefresh();
			}, 1000);
			this.clockTimer.unref?.();
		}
	}

	handleInput(data: string): void {
		const activity = this.current();
		if (!activity) {
			this.done();
			return;
		}
		if (activity.kind !== "terminal" || !isActive(activity)) {
			if (data === "x" && isActive(activity)) {
				this.stopFailed = false;
				void this.manager.stop(this.id).catch(() => {
					this.stopFailed = true;
					this.scheduleRefresh();
				});
				this.scheduleRefresh();
				return;
			}
			if (
				this.keybindings.matches(data, "tui.select.cancel") ||
				matchesKey(data, "escape") ||
				matchesKey(data, "ctrl+c") ||
				matchesKey(data, "ctrl+g")
			)
				this.done();
			return;
		}
		const input = terminalInput(data);
		if (input?.detach) {
			this.done();
			return;
		}
		if (input?.text && activity.status === "running") {
			try {
				this.manager.write(this.id, input.text, input.paste, true);
			} catch {
				this.done();
			}
		}
	}

	render(width: number): string[] {
		this.renderedWidth = Math.max(1, width);
		this.scheduleResize();
		const activity = this.current();
		if (!activity)
			return [
				this.theme.fg(
					"warning",
					truncateToWidth("Activity no longer exists", width, ""),
				),
			];
		const height = Math.max(1, Math.floor(this.tui.terminal.rows * 0.9));
		if (width < 22 || height < 11)
			return [
				this.theme.fg(
					"muted",
					truncateToWidth("Activities: enlarge terminal", width, ""),
				),
			];
		const view =
			activity.kind === "terminal"
				? this.manager.terminalView(this.id)
				: undefined;
		const lines = renderActivityFrame(activity, width, height, {
			view,
			theme: this.theme,
			backToPicker: this.backToPicker,
			stopFailed: this.stopFailed,
			timer:
				activity.kind === "timer" ? this.manager.timerView(this.id) : undefined,
		});
		const screen = activity.screen;
		if (
			this.focused &&
			activity.status === "running" &&
			screen &&
			!screen.truncated &&
			(!view || view.cursor)
		) {
			const row = (view?.cursor?.y ?? screen.cursorY) + 3;
			const column = (view?.cursor?.x ?? screen.cursorX) + 1;
			if (row < lines.length - 2 && column < width - 1) {
				const line = lines[row];
				const cursor = view?.cursor;
				const cell = cursor?.text ?? (sliceByColumn(line, column, 1) || " ");
				const cellWidth = cursor?.width ?? visibleWidth(cell);
				const style = cursor?.style ?? "";
				const painted = this.tui.getShowHardwareCursor()
					? cell
					: cursor?.inverse
						? `\x1b[27m${cell}`
						: renderFakeCursor(cell);
				lines[row] =
					sliceByColumn(line, 0, column, true) +
					style +
					CURSOR_MARKER +
					painted +
					style +
					sliceByColumn(
						line,
						column + cellWidth,
						width - column - cellWidth,
						true,
					) +
					RESET;
			}
		}
		return lines;
	}

	invalidate(): void {}

	dispose(): void {
		if (this.disposed) return;
		this.disposed = true;
		// Closing an inspected finished activity acknowledges its failure.
		const activity = this.current();
		if (activity && !isActive(activity))
			try {
				this.manager.acknowledge(this.id);
			} catch {}
		this.unsubscribe?.();
		if (this.refreshTimer) clearTimeout(this.refreshTimer);
		if (this.resizeTimer) clearTimeout(this.resizeTimer);
		if (this.clockTimer) clearInterval(this.clockTimer);
	}

	private current(): ActivitySnapshot | undefined {
		try {
			return this.manager.read(this.id);
		} catch {
			return undefined;
		}
	}

	private scheduleRefresh(): void {
		if (this.disposed || this.refreshTimer) return;
		this.refreshTimer = setTimeout(() => {
			this.refreshTimer = undefined;
			if (!this.disposed) this.tui.requestRender();
		}, REFRESH_MS);
	}

	private scheduleResize(): void {
		if (this.disposed || this.resizeTimer) return;
		this.resizeTimer = setTimeout(() => {
			this.resizeTimer = undefined;
			const activity = this.current();
			if (
				this.disposed ||
				activity?.kind !== "terminal" ||
				activity.status !== "running" ||
				this.renderedWidth < 22 ||
				this.tui.terminal.rows < 13
			)
				return;
			const cols = clamp(this.renderedWidth - 2, MIN_COLS, MAX_COLS);
			const rows = clamp(
				Math.floor(this.tui.terminal.rows * 0.9) - 6,
				MIN_ROWS,
				MAX_ROWS,
			);
			if (activity.screen?.cols === cols && activity.screen.rows === rows)
				return;
			try {
				this.manager.resize(this.id, cols, rows);
			} catch {
				this.done();
			}
		}, 0);
	}
}

function statusColor(activity: ActivitySnapshot) {
	if (activity.status === "completed") return "success" as const;
	if (activity.status === "failed") return "error" as const;
	if (activity.status === "running") return "accent" as const;
	return "warning" as const;
}

function clamp(value: number, min: number, max: number): number {
	return Math.min(max, Math.max(min, value));
}

function errorMessage(error: unknown): string {
	return error instanceof Error ? error.message : String(error);
}