one-code-extension 0.1.4 → 0.3.1

package/extensions/plugins/marketplace/sync.ts

@@ -0,0 +1,146 @@
+/**
+ * Marketplace content sync: make a registered marketplace's manifest readable
+ * locally (clone/fetch/read per source type) and parse it into a snapshot.
+ *
+ * Network and git run only from explicit panel actions (open/refresh/add) —
+ * never at session start.
+ */
+
+import { existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { readJsonFile, writeJsonAtomic } from "../../lib/atomic-write.ts";
+import { fetchWithTimeout } from "../../lib/fetch-timeout.ts";
+import { gitClone, gitUpdate } from "./git.ts";
+import { writeKnownMarketplace } from "./registry.ts";
+import {
+	type KnownMarketplace,
+	type MarketplaceManifest,
+	type MarketplaceSource,
+	parseMarketplaceManifest,
+} from "./types.ts";
+
+export interface MarketplaceSnapshot {
+	name: string;
+	known: KnownMarketplace;
+	manifest?: MarketplaceManifest;
+	errors: string[];
+	/** Directory plugin `./relative` sources resolve against (clone/local root). */
+	contentRoot?: string;
+}
+
+export function marketplaceCacheDir(root: string): string {
+	return join(root, "marketplaces");
+}
+
+/** Where a source's content lives under our root (clone dir or cached .json). */
+export function installLocationFor(root: string, name: string, source: MarketplaceSource): string {
+	return source.source === "url" ? join(marketplaceCacheDir(root), `${name}.json`) : join(marketplaceCacheDir(root), name);
+}
+
+function cloneUrl(source: MarketplaceSource): string | undefined {
+	if (source.source === "github") return `https://github.com/${source.repo}.git`;
+	if (source.source === "git") return source.url;
+	return undefined;
+}
+
+const FETCH_TIMEOUT_MS = 10_000;
+
+async function fetchManifestJson(url: string): Promise<unknown> {
+	const response = await fetchWithTimeout(url, FETCH_TIMEOUT_MS, { headers: { "user-agent": "one-code-plugins" } });
+	if (!response.ok) throw new Error(`HTTP ${response.status}`);
+	return await response.json();
+}
+
+/**
+ * Ensure the marketplace's content is present (clone/fetch when missing,
+ * update when `refresh`), then parse its manifest. Errors are reported in the
+ * snapshot, never thrown — offline opens degrade to whatever is cached.
+ */
+export async function syncMarketplace(
+	root: string,
+	name: string,
+	known: KnownMarketplace,
+	options: { refresh?: boolean } = {},
+): Promise<MarketplaceSnapshot> {
+	const errors: string[] = [];
+	const { source } = known;
+	let manifestPath: string | undefined;
+	let contentRoot: string | undefined;
+	let synced = false;
+
+	const url = cloneUrl(source);
+	if (url) {
+		const dest = installLocationFor(root, name, source);
+		try {
+			if (!existsSync(dest)) {
+				await gitClone(url, dest, { ref: source.source === "github" || source.source === "git" ? source.ref : undefined });
+				synced = true;
+			} else if (options.refresh) {
+				try {
+					await gitUpdate(dest, { ref: source.source === "github" || source.source === "git" ? source.ref : undefined });
+				} catch {
+					// In-place update failed (force-push, sparse transition, corrupt
+					// clone): re-clone from scratch rather than serving a broken tree.
+					// The existing clone stays in place until the replacement clone
+					// succeeds — gitClone builds in a temp dir and renames over dest,
+					// so a failed re-clone keeps serving the stale content.
+					await gitClone(url, dest, { ref: source.source === "github" || source.source === "git" ? source.ref : undefined });
+				}
+				synced = true;
+			}
+		} catch (error) {
+			errors.push(`${name}: ${(error as Error).message}`);
+		}
+		if (existsSync(dest)) {
+			contentRoot = dest;
+			manifestPath = join(dest, ".claude-plugin", "marketplace.json");
+		}
+	} else if (source.source === "url") {
+		const cache = installLocationFor(root, name, source);
+		if (!existsSync(cache) || options.refresh) {
+			try {
+				const fetched = await fetchManifestJson(source.url);
+				const validated = parseMarketplaceManifest(fetched);
+				if (!validated.manifest) {
+					errors.push(...validated.errors.map((e) => `${name}: ${e}`));
+				} else {
+					writeJsonAtomic(cache, fetched);
+					synced = true;
+				}
+			} catch (error) {
+				errors.push(`${name}: could not fetch ${source.url} (${(error as Error).message})`);
+			}
+		}
+		if (existsSync(cache)) manifestPath = cache;
+	} else if (source.source === "file") {
+		manifestPath = source.path;
+		contentRoot = join(source.path, "..", "..");
+	} else if (source.source === "directory") {
+		contentRoot = source.path;
+		manifestPath = join(source.path, ".claude-plugin", "marketplace.json");
+	}
+
+	let manifest: MarketplaceManifest | undefined;
+	if (manifestPath && existsSync(manifestPath) && statSync(manifestPath).isFile()) {
+		const raw = readJsonFile<unknown>(manifestPath);
+		if (raw === undefined) {
+			errors.push(`${name}: ${manifestPath} is not valid JSON`);
+		} else {
+			const validated = parseMarketplaceManifest(raw);
+			manifest = validated.manifest;
+			errors.push(...validated.errors.map((e) => `${name}: ${e}`));
+		}
+	} else if (errors.length === 0) {
+		errors.push(`${name}: no marketplace.json found${manifestPath ? ` at ${manifestPath}` : ""}`);
+	}
+
+	// Return the post-write entry so callers can update their in-memory
+	// registry copy instead of re-reading known_marketplaces.json.
+	let updatedKnown = known;
+	if (synced) {
+		updatedKnown = { ...known, lastUpdated: new Date().toISOString() };
+		writeKnownMarketplace(root, name, updatedKnown);
+	}
+
+	return { name, known: updatedKnown, manifest, errors, contentRoot };
+}

package/extensions/plugins/marketplace/types.ts

@@ -0,0 +1,128 @@
+/**
+ * Marketplace data shapes + hand-rolled validators (pure).
+ *
+ * The formats are Claude Code's: `known_marketplaces.json` records where each
+ * marketplace came from and where its content is cached; a marketplace's
+ * `.claude-plugin/marketplace.json` lists plugin entries whose `source` says
+ * how to materialize the plugin's files. Validation is per-entry — one bad
+ * entry never blanks the rest of the marketplace.
+ */
+
+export type MarketplaceSource =
+	| { source: "github"; repo: string; ref?: string }
+	| { source: "git"; url: string; ref?: string }
+	| { source: "url"; url: string }
+	| { source: "file"; path: string }
+	| { source: "directory"; path: string };
+
+export interface KnownMarketplace {
+	source: MarketplaceSource;
+	installLocation: string;
+	lastUpdated: string;
+	autoUpdate?: boolean;
+}
+
+/** How one plugin's files are obtained. A string is a path relative to the marketplace root. */
+export type PluginEntrySource =
+	| string
+	| { source: "github"; repo: string; ref?: string; sha?: string }
+	| { source: "git-subdir"; url: string; path: string; ref?: string; sha?: string }
+	| { source: "url"; url: string; ref?: string; sha?: string };
+
+export interface MarketplaceEntry {
+	name: string;
+	source: PluginEntrySource;
+	description?: string;
+	version?: string;
+	author?: { name?: string };
+	category?: string;
+	tags?: string[];
+	/** The full raw entry — the detail view shows contributions (lspServers, mcpServers, …) from it. */
+	raw: Record<string, unknown>;
+}
+
+export interface MarketplaceManifest {
+	name: string;
+	owner?: { name?: string };
+	description?: string;
+	plugins: MarketplaceEntry[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function validEntrySource(value: unknown): value is PluginEntrySource {
+	// A string source is a marketplace-relative path and must say so ("./…").
+	if (typeof value === "string") return value.startsWith("./");
+	if (!isRecord(value)) return false;
+	switch (value.source) {
+		case "github":
+			return typeof value.repo === "string" && value.repo.length > 0;
+		case "git-subdir":
+			return typeof value.url === "string" && typeof value.path === "string" && value.path.length > 0;
+		case "url":
+			return typeof value.url === "string" && value.url.length > 0;
+		default:
+			return false;
+	}
+}
+
+/** Validate a parsed marketplace.json. Entry-level problems land in `errors`; good entries survive. */
+export function parseMarketplaceManifest(raw: unknown): { manifest?: MarketplaceManifest; errors: string[] } {
+	const errors: string[] = [];
+	if (!isRecord(raw)) return { errors: ["marketplace.json must be a JSON object"] };
+	if (typeof raw.name !== "string" || raw.name.length === 0) {
+		return { errors: ['marketplace.json is missing a "name"'] };
+	}
+	if (!Array.isArray(raw.plugins)) {
+		return { errors: [`marketplace "${raw.name}" has no "plugins" array`] };
+	}
+
+	const plugins: MarketplaceEntry[] = [];
+	for (const [index, entry] of raw.plugins.entries()) {
+		if (!isRecord(entry) || typeof entry.name !== "string" || entry.name.length === 0 || entry.name.includes(" ")) {
+			errors.push(`plugins[${index}]: missing or invalid "name" — entry skipped`);
+			continue;
+		}
+		if (!validEntrySource(entry.source)) {
+			errors.push(`plugins[${index}] ("${entry.name}"): missing or unsupported "source" — entry skipped`);
+			continue;
+		}
+		plugins.push({
+			name: entry.name,
+			source: entry.source as PluginEntrySource,
+			description: typeof entry.description === "string" ? entry.description : undefined,
+			version: typeof entry.version === "string" ? entry.version : undefined,
+			author: isRecord(entry.author) && typeof entry.author.name === "string" ? { name: entry.author.name } : undefined,
+			category: typeof entry.category === "string" ? entry.category : undefined,
+			tags: Array.isArray(entry.tags) ? entry.tags.filter((t): t is string => typeof t === "string") : undefined,
+			raw: entry,
+		});
+	}
+
+	const owner = isRecord(raw.owner) && typeof raw.owner.name === "string" ? { name: raw.owner.name } : undefined;
+	const metadata = isRecord(raw.metadata) ? raw.metadata : undefined;
+	return {
+		manifest: {
+			name: raw.name,
+			owner,
+			description: typeof metadata?.description === "string" ? (metadata.description as string) : undefined,
+			plugins,
+		},
+		errors,
+	};
+}
+
+/** Validate one known_marketplaces.json value; undefined when malformed. */
+export function parseKnownMarketplace(raw: unknown): KnownMarketplace | undefined {
+	if (!isRecord(raw) || !isRecord(raw.source) || typeof raw.installLocation !== "string") return undefined;
+	const source = raw.source as MarketplaceSource;
+	if (!["github", "git", "url", "file", "directory"].includes(source.source)) return undefined;
+	return {
+		source,
+		installLocation: raw.installLocation,
+		lastUpdated: typeof raw.lastUpdated === "string" ? raw.lastUpdated : new Date(0).toISOString(),
+		autoUpdate: typeof raw.autoUpdate === "boolean" ? raw.autoUpdate : undefined,
+	};
+}

package/extensions/plugins/panel/keys.ts

@@ -0,0 +1,52 @@
+/**
+ * Raw-byte key decoding for the /plugins panel (pure).
+ *
+ * Navigation bytes are always controls; any other printable input is a `text`
+ * intent the state layer routes (search box, Add Marketplace draft, or a
+ * single-letter action where the active view has no text field). Unrecognized
+ * escape sequences are swallowed so they never leak into a draft.
+ */
+
+export type PanelKey =
+	| { kind: "up" | "down" | "pageUp" | "pageDown" | "nextTab" | "prevTab" | "enter" | "back" | "space" | "backspace" | "close" }
+	| { kind: "text"; text: string };
+
+export function decodePanelKey(data: string): PanelKey | undefined {
+	switch (data) {
+		case "\x1b[A":
+		case "\x1bOA":
+			return { kind: "up" };
+		case "\x1b[B":
+		case "\x1bOB":
+			return { kind: "down" };
+		case "\x1b[5~":
+			return { kind: "pageUp" };
+		case "\x1b[6~":
+			return { kind: "pageDown" };
+		case "\x1b[C":
+		case "\x1bOC":
+		case "\t":
+			return { kind: "nextTab" };
+		case "\x1b[D":
+		case "\x1bOD":
+		case "\x1b[Z":
+			return { kind: "prevTab" };
+		case "\r":
+		case "\n":
+			return { kind: "enter" };
+		case "\x1b":
+			return { kind: "back" };
+		case " ":
+			return { kind: "space" };
+		case "\x7f":
+		case "\b":
+			return { kind: "backspace" };
+		case "\x03": // ctrl+c
+			return { kind: "close" };
+		default:
+			break;
+	}
+	if (data.startsWith("\x1b")) return undefined;
+	const text = [...data].filter((ch) => ch >= " " && ch !== "\x7f").join("");
+	return text ? { kind: "text", text } : undefined;
+}

package/extensions/plugins/panel/render.ts

@@ -0,0 +1,315 @@
+/**
+ * /plugins panel rendering (pure).
+ *
+ * Returns plain lines already cut to width; the wiring wraps them in a
+ * memoized component and applies a final ANSI-aware truncate (pi-tui crashes
+ * on overwide lines, so both layers guard).
+ */
+
+import { formatInstallCount } from "../counts.ts";
+import { cutPlainText, panelTopRule, type RenderBlock as Block, searchBoxLines, windowBlocks } from "../../lib/tui-render.ts";
+import type { DiscoverRow, InstalledRow } from "./rows.ts";
+import { clampPanelState, type PanelState, type PanelView, resolveDetail, selectableRows, TABS, type Tab } from "./state.ts";
+
+export interface PanelPaint {
+	fg: (color: string, text: string) => string;
+	bold: (text: string) => string;
+	inverse: (text: string) => string;
+}
+
+/** Detail-view extras the row model doesn't carry (from the marketplace manifest). */
+export interface DiscoverDetail {
+	version?: string;
+	author?: string;
+	category?: string;
+	contributions: string[];
+}
+
+export interface PanelRenderInput {
+	state: PanelState;
+	view: PanelView;
+	width: number;
+	height: number;
+	/** Active async operations, e.g. "cloning claude-plugins-official…". */
+	loading: string[];
+	discoverDetails: Map<string, DiscoverDetail>;
+	restartNeeded: boolean;
+}
+
+export const TRUST_NOTE =
+	"Make sure you trust a plugin before installing or enabling it: plugins can run commands, add MCP servers, and start language servers on your machine. One Code does not review plugin content — check the plugin's homepage and source.";
+
+const TAB_TITLES: Record<Tab, string> = {
+	discover: "Discover",
+	installed: "Installed",
+	marketplaces: "Marketplaces",
+	errors: "Errors",
+};
+
+function tabBar(state: PanelState, view: PanelView, paint: PanelPaint, width: number): string {
+	const chips = TABS.map((tab) => {
+		const title = tab === "errors" && view.errors.length > 0 ? `${TAB_TITLES[tab]} (${view.errors.length})` : TAB_TITLES[tab];
+		return tab === state.tab ? paint.inverse(` ${title} `) : ` ${title} `;
+	});
+	return ` ${paint.bold("Plugins")} ${chips.join(" ")}`.slice(0, width * 4);
+}
+
+function discoverBlocks(input: PanelRenderInput, paint: PanelPaint): Block[] {
+	const { state, view, width } = input;
+	const cursorRow = selectableRows(state, view)[state.cursor.discover];
+	return view.discover.map((row) => {
+		const isCursor = row === cursorRow;
+		const marker = isCursor ? "❯" : " ";
+		const dot = row.busy ? "…" : row.installed ? "●" : "○";
+		const installs = row.installs !== undefined ? ` · ${formatInstallCount(row.installs)} installs` : "";
+		const head = cutPlainText(`${marker} ${dot} ${row.name} · ${row.marketplace}${installs}`, width - 1);
+		const painted = isCursor ? paint.fg("accent", head) : head;
+		const lines = [painted];
+		if (row.description) lines.push(paint.fg("dim", cutPlainText(`    ${row.description}`, width - 1)));
+		return { lines, selectable: true };
+	});
+}
+
+function installedLine(row: Exclude<InstalledRow, { kind: "section" }>, paint: PanelPaint): string {
+	const on = paint.fg("success", "✔");
+	const off = paint.fg("error", "✘");
+	if (row.kind === "plugin") {
+		const state = row.busy ? "…" : row.enabled ? `${on} enabled` : `${off} disabled`;
+		const override = row.overridden ? " · One Code override" : "";
+		const marketplace = row.marketplace ? ` · ${row.marketplace}` : "";
+		return `${row.name} Plugin${marketplace} · ${state}${override}`;
+	}
+	if (row.kind === "mcp") {
+		const status =
+			row.status === "connected"
+				? `${on} connected${row.toolCount !== undefined ? ` (${row.toolCount} tools)` : ""}`
+				: row.status === "authNeeded"
+					? paint.fg("warning", `⚠ needs auth${row.detail ? ` — ${row.detail}` : ""}`)
+					: row.status === "connecting"
+						? "… connecting"
+						: `${off} failed${row.detail ? ` — ${row.detail}` : ""}`;
+		return `${row.name} MCP · ${status}`;
+	}
+	const toggle = row.enabled ? `${on} on` : `${off} off`;
+	return `${row.name} Skill · ${row.scope} · ${toggle} · ~${row.tokens} tok · ${row.recency}`;
+}
+
+function installedBlocks(input: PanelRenderInput, paint: PanelPaint): Block[] {
+	const { state, view, width } = input;
+	const cursorRow = selectableRows(state, view)[state.cursor.installed];
+	return view.installed.map((row) => {
+		if (row.kind === "section") {
+			return { lines: ["", paint.bold(cutPlainText(` ${row.title}`, width - 1))], selectable: false };
+		}
+		const isCursor = row === cursorRow;
+		const marker = isCursor ? "❯ " : "  ";
+		const line = `${marker}${installedLine(row, paint)}`;
+		return { lines: [isCursor ? paint.fg("accent", line) : line], selectable: true };
+	});
+}
+
+function marketplaceBlocks(input: PanelRenderInput, paint: PanelPaint): Block[] {
+	const { state, view, width } = input;
+	const cursorRow = selectableRows(state, view)[state.cursor.marketplaces];
+	return view.marketplaces.map((row) => {
+		const isCursor = row === cursorRow;
+		const marker = isCursor ? "❯" : "●";
+		if (row.kind === "add") {
+			const line = `${isCursor ? "❯" : " "} + Add Marketplace`;
+			return { lines: [isCursor ? paint.fg("accent", line) : paint.bold(line), ""], selectable: true };
+		}
+		const star = row.official ? paint.fg("error", " ✳ ") : " ";
+		const name = `${marker}${star}${paint.bold(row.name)}${row.official ? paint.fg("error", " ✳") : ""}`;
+		const counts = [
+			row.available !== undefined ? `${row.available} available` : "not synced",
+			`${row.installedCount} installed`,
+			`Updated ${row.updated.slice(0, 10)}`,
+		].join(" • ");
+		const lines = [
+			isCursor ? paint.fg("accent", cutPlainText(name, width * 2)) : cutPlainText(name, width * 2),
+			paint.fg("dim", cutPlainText(`   ${row.sourceLine}`, width - 1)),
+			paint.fg("dim", cutPlainText(`   ${counts}`, width - 1)),
+		];
+		if (row.error) lines.push(paint.fg("error", cutPlainText(`   ${row.error}`, width - 1)));
+		lines.push("");
+		return { lines, selectable: true };
+	});
+}
+
+function addDialogLines(draft: string, paint: PanelPaint, width: number): string[] {
+	const inner = Math.max(30, Math.min(width - 4, 78));
+	const border = (ch: string) => `┌${ch.repeat(inner)}┐`;
+	const boxLine = (text: string, style?: (t: string) => string) => {
+		const cut = cutPlainText(text, inner - 2);
+		const padded = ` ${cut}${" ".repeat(Math.max(0, inner - 2 - cut.length))} `;
+		return `│${style ? style(padded) : padded}│`;
+	};
+	return [
+		border("─"),
+		boxLine("Add Marketplace", paint.bold),
+		boxLine(""),
+		boxLine("Enter marketplace source:"),
+		boxLine(draft ? draft : "…", draft ? undefined : (t) => paint.fg("dim", t)),
+		boxLine(""),
+		boxLine("Examples:", (t) => paint.fg("dim", t)),
+		boxLine("· owner/repo (GitHub)", (t) => paint.fg("dim", t)),
+		boxLine("· git@github.com:owner/repo.git (SSH)", (t) => paint.fg("dim", t)),
+		boxLine("· https://example.com/marketplace.json", (t) => paint.fg("dim", t)),
+		boxLine("· ./path/to/marketplace", (t) => paint.fg("dim", t)),
+		`└${"─".repeat(inner)}┘`,
+	];
+}
+
+function detailLines(input: PanelRenderInput, paint: PanelPaint): { lines: string[]; footer: string } {
+	const { state, view, width } = input;
+	const ref = state.detail;
+	const row = ref ? resolveDetail(ref, view) : undefined;
+	if (!ref || !row) return { lines: [paint.fg("dim", "  (no longer available)")], footer: "Esc to go back" };
+
+	const lines: string[] = [];
+	const push = (text: string, style?: (t: string) => string) => {
+		const cut = cutPlainText(text, width - 2);
+		lines.push(style ? ` ${style(cut)}` : ` ${cut}`);
+	};
+
+	if (ref.kind === "discover") {
+		const discover = row as DiscoverRow;
+		const detail = input.discoverDetails.get(discover.id);
+		push(`${discover.name} · ${discover.marketplace}`, paint.bold);
+		if (discover.description) push(discover.description);
+		push("");
+		if (detail?.version) push(`Version: ${detail.version}`, (t) => paint.fg("dim", t));
+		if (detail?.author) push(`Author: ${detail.author}`, (t) => paint.fg("dim", t));
+		if (detail?.category) push(`Category: ${detail.category}`, (t) => paint.fg("dim", t));
+		if (discover.installs !== undefined) push(`${formatInstallCount(discover.installs)} installs`, (t) => paint.fg("dim", t));
+		if (detail?.contributions.length) {
+			push("");
+			push("Provides:", paint.bold);
+			for (const item of detail.contributions) push(`· ${item}`);
+		}
+		push("");
+		for (const noteLine of wrapNote(TRUST_NOTE, width - 4)) push(noteLine, (t) => paint.fg("warning", t));
+		const footer = discover.busy
+			? "working…"
+			: discover.installed
+				? "u to uninstall · Esc to go back"
+				: "i to install · Esc to go back";
+		return { lines, footer };
+	}
+
+	if ("kind" in row && row.kind === "plugin") {
+		push(`${row.name} Plugin${row.marketplace ? ` · ${row.marketplace}` : ""}`, paint.bold);
+		push(`Origin: ${row.origin === "one-code" ? "installed by One Code" : "installed by Claude Code (read-only files)"}`);
+		push(`State: ${row.enabled ? "enabled" : "disabled"}${row.overridden ? " (One Code override)" : ""}`);
+		push("");
+		for (const noteLine of wrapNote(TRUST_NOTE, width - 4)) push(noteLine, (t) => paint.fg("warning", t));
+		const uninstall = row.origin === "one-code" ? " · u to uninstall" : "";
+		const overrideNote = row.origin === "claude" ? " (One Code override — Claude Code settings untouched)" : "";
+		return { lines, footer: `Enter/Space/e/d to toggle${overrideNote}${uninstall} · f to favorite · Esc to go back` };
+	}
+
+	if ("kind" in row && row.kind === "skill") {
+		push(`${row.name} Skill · ${row.scope}`, paint.bold);
+		push(`State: ${row.enabled ? "on" : "off"} · ~${row.tokens} tok · ${row.recency}`);
+		return { lines, footer: "Enter/Space/e/d to toggle · f to favorite · Esc to go back" };
+	}
+
+	if ("kind" in row && row.kind === "mcp") {
+		push(`${row.name} MCP server`, paint.bold);
+		push(`Status: ${row.status}${row.detail ? ` — ${row.detail}` : ""}`);
+		if (row.source) push(`Source: ${row.source}`, (t) => paint.fg("dim", t));
+		return { lines, footer: "Esc to go back" };
+	}
+
+	return { lines, footer: "Esc to go back" };
+}
+
+function wrapNote(text: string, width: number): string[] {
+	const words = text.split(" ");
+	const lines: string[] = [];
+	let current = "";
+	for (const word of words) {
+		if (current && current.length + word.length + 1 > Math.max(20, width)) {
+			lines.push(current);
+			current = word;
+		} else {
+			current = current ? `${current} ${word}` : word;
+		}
+	}
+	if (current) lines.push(current);
+	return lines;
+}
+
+/** Footer hints per tab; a second line keeps the Installed hints readable at 80 columns. */
+const FOOTERS: Record<Tab, string[]> = {
+	discover: ["Type to search · Space to install/uninstall · Enter to view · ←/→ tabs · Esc to close"],
+	installed: ["Enter/Space to toggle · v to view · f to favorite · u to uninstall", "/ to search · ←/→ tabs · Esc to close"],
+	marketplaces: ["Enter to select · a to add · u to update · d to remove · Esc to close"],
+	errors: ["←/→ tabs · Esc to close"],
+};
+/** Installed search hints while the `/` box is open (Esc leaves it). */
+const INSTALLED_SEARCH_FOOTER = ["Type to search · Enter/Space to toggle · Esc to leave search"];
+
+export function renderPanel(input: PanelRenderInput, paint: PanelPaint): string[] {
+	const { state, view, width, height } = input;
+	clampPanelState(state, view);
+
+	const out: string[] = [panelTopRule(paint.fg, width), tabBar(state, view, paint, width), ""];
+	let footer: string[];
+
+	if (state.addDialog) {
+		out.push(...addDialogLines(state.addDialog.draft, paint, width));
+		footer = ["Enter to add · Esc to cancel"];
+	} else if (state.detail) {
+		const detail = detailLines(input, paint);
+		out.push(...detail.lines);
+		footer = [detail.footer];
+	} else {
+		let blocks: Block[];
+		switch (state.tab) {
+			case "discover": {
+				const total = view.discover.length;
+				const position = total === 0 ? 0 : state.cursor.discover + 1;
+				out.push(paint.bold(cutPlainText(` Discover plugins (${position}/${total})`, width - 1)), "");
+				out.push(...searchBoxLines(state.search.discover, "Search…", paint.fg, width), "");
+				blocks = discoverBlocks(input, paint);
+				break;
+			}
+			case "installed": {
+				const placeholder = state.installedSearching ? "Search…" : "Press / to search…";
+				out.push(...searchBoxLines(state.search.installed, placeholder, paint.fg, width));
+				blocks = installedBlocks(input, paint);
+				break;
+			}
+			case "marketplaces": {
+				out.push(paint.bold(" Manage marketplaces"), "");
+				blocks = marketplaceBlocks(input, paint);
+				break;
+			}
+			case "errors": {
+				blocks = view.errors.length
+					? view.errors.map((error) => ({ lines: [cutPlainText(`  ${error}`, width - 1)], selectable: true }))
+					: [{ lines: [paint.fg("dim", "  No plugin errors")], selectable: false }];
+				break;
+			}
+		}
+		footer = state.tab === "installed" && state.installedSearching ? INSTALLED_SEARCH_FOOTER : FOOTERS[state.tab];
+		const budget = Math.max(3, height - out.length - 2 - footer.length);
+		const windowed = windowBlocks(blocks, state.cursor[state.tab], budget);
+		out.push(...windowed.lines);
+		if (windowed.more > 0) out.push(paint.fg("dim", `  ↓ more below (${windowed.more})`));
+	}
+
+	for (const loading of input.loading) out.push(paint.fg("dim", cutPlainText(`  ${loading}`, width - 1)));
+	if (state.notice) out.push(paint.fg("warning", cutPlainText(`  ${state.notice}`, width - 1)));
+	if (input.restartNeeded) {
+		out.push(
+			paint.fg(
+				"warning",
+				cutPlainText("  Some changes (MCP servers, agents, hooks) apply on the next session restart.", width - 1),
+			),
+		);
+	}
+	out.push("", ...footer.map((line) => paint.fg("dim", cutPlainText(` ${line}`, width - 1))));
+	return out;
+}