@oh-my-pi/pi-tui 18.2.3 → 18.2.5

package/src/overlays/extensions/live-tool-session.ts

@@ -0,0 +1,67 @@
+export interface LiveToolInfo {
+	name: string;
+	sourceInfo: { source: string; path?: string };
+}
+import type { LiveToolRecord, ToolRuntimeSource } from "./inspector-model";
+
+/** Session methods the `/extensions` live-tool join actually uses. */
+export interface LiveToolSessionLookup {
+	getToolByName(name: string):
+		| {
+				name: string;
+				label?: string;
+				description?: string;
+				parameters?: unknown;
+				hidden?: boolean;
+				loadMode?: "essential" | "discoverable";
+		  }
+		| undefined;
+	getAllToolInfos(): LiveToolInfo[];
+}
+
+/** Convert an already-fetched ToolInfo plus the registered tool. */
+export function liveToolRecordFromInfo(session: LiveToolSessionLookup, info: LiveToolInfo): LiveToolRecord | undefined {
+	const tool = session.getToolByName(info.name);
+	if (!tool) return undefined;
+	const origin = info.sourceInfo.source;
+	const originPath = info.sourceInfo.path;
+	return {
+		name: tool.name,
+		label: tool.label,
+		description: tool.description,
+		parameters: tool.parameters,
+		hidden: tool.hidden,
+		loadMode: tool.loadMode,
+		source:
+			origin === "builtin" || origin === "mcp" || origin === "sdk" || origin === "extension" ? origin : undefined,
+		sourcePath: originPath && !originPath.startsWith("<") ? originPath : undefined,
+	};
+}
+
+/** One-name lookup. Obtains a fresh ToolInfo snapshot for that name. */
+export function liveToolRecordFromSession(session: LiveToolSessionLookup, name: string): LiveToolRecord | undefined {
+	const info = session.getAllToolInfos().find(entry => entry.name === name);
+	return info ? liveToolRecordFromInfo(session, info) : undefined;
+}
+
+/** List every live tool. Calls `getAllToolInfos()` once. */
+export function listLiveToolRecords(session: LiveToolSessionLookup): LiveToolRecord[] {
+	const tools: LiveToolRecord[] = [];
+	for (const info of session.getAllToolInfos()) {
+		const live = liveToolRecordFromInfo(session, info);
+		if (live) tools.push(live);
+	}
+	return tools;
+}
+
+/** One list snapshot for a dashboard/list/inspector render. Not a persistent cache. */
+export function snapshotToolRuntimeSource(source: ToolRuntimeSource | undefined): ToolRuntimeSource | undefined {
+	if (!source) return undefined;
+	if (!source.listLiveTools) return source;
+	const listed = source.listLiveTools();
+	const byName = new Map(listed.map(entry => [entry.name, entry]));
+	return {
+		getLiveTool: name => byName.get(name),
+		listLiveTools: () => listed,
+	};
+}

package/src/overlays/extensions/mcp-runtime.ts

@@ -0,0 +1,289 @@
+/**
+ * Live MCP runtime view-model for `/extensions`.
+ *
+ * Discovery yields config (`MCPServer`). `MCPManager` holds the live connection.
+ * This module joins them by server name without stuffing runtime objects into
+ * `Extension.raw`.
+ */
+/** Config and connection fields actually consumed by the dashboard. */
+export interface MCPServerConfigDisplay {
+	type?: string;
+	transport?: string;
+	command?: string;
+	args?: string[];
+	url?: string;
+	env?: Record<string, unknown>;
+}
+
+export interface MCPServerDisplay extends MCPServerConfigDisplay {
+	name: string;
+	enabled?: boolean;
+	_source: unknown;
+}
+
+export interface MCPImplementationDisplay {
+	name: string;
+	version?: string;
+	title?: string;
+	description?: string;
+	websiteUrl?: string;
+}
+
+export interface MCPResourceDisplay {
+	name: string;
+	title?: string;
+	description?: string;
+	uri?: string;
+	uriTemplate?: string;
+}
+
+export interface MCPConnectionDisplay {
+	name: string;
+	config: MCPServerConfigDisplay;
+	serverInfo?: MCPImplementationDisplay;
+	instructions?: string;
+	tools?: Array<{
+		name: string;
+		title?: string;
+		description?: string;
+		annotations?: { title?: string };
+		inputSchema?: unknown;
+	}>;
+	resources?: MCPResourceDisplay[];
+	resourceTemplates?: MCPResourceDisplay[];
+	prompts?: MCPResourceDisplay[];
+}
+
+import { PREVIEW_LIMITS } from "../../render/render-utils";
+import {
+	sanitizeDisplayField,
+	sanitizeDisplayLine,
+	sanitizeDisplayLineField,
+	sanitizeDisplayText,
+} from "./display-text";
+
+export type MCPConnectionHealth = "connected" | "connecting" | "disconnected" | "inactive";
+
+export interface MCPRuntimeCatalogItem {
+	name: string;
+	title?: string;
+	description?: string;
+	/** MCP `inputSchema` / bridged `parameters`. Rendered on expand. */
+	parameters?: unknown;
+}
+
+export interface MCPRuntimeSnapshot {
+	health: MCPConnectionHealth;
+	transport: "stdio" | "sse" | "http";
+	title?: string;
+	description?: string;
+	websiteUrl?: string;
+	implementationName?: string;
+	implementationVersion?: string;
+	instructions?: string;
+	tools: MCPRuntimeCatalogItem[];
+	resources: MCPRuntimeCatalogItem[];
+	prompts: MCPRuntimeCatalogItem[];
+	command?: string;
+	args?: string[];
+	url?: string;
+	envCount: number;
+}
+
+/** Narrow manager surface so tests can stub without constructing MCPManager. */
+export interface MCPRuntimeSource {
+	getConnectionStatus(name: string): "connected" | "connecting" | "disconnected";
+	getConnection(name: string): MCPConnectionDisplay | undefined;
+	getTools(): Array<{
+		mcpServerName?: string;
+		mcpToolName?: string;
+		description?: string;
+		label?: string;
+		parameters?: unknown;
+	}>;
+	getServerResources?(name: string): { resources: MCPResourceDisplay[]; templates: MCPResourceDisplay[] } | undefined;
+	getServerPrompts?(name: string): MCPResourceDisplay[] | undefined;
+}
+
+const DEFAULT_VISIBLE_TOOLS = PREVIEW_LIMITS.COLLAPSED_ITEMS;
+
+export function isDiscoveredMcpServer(raw: unknown): raw is MCPServerDisplay {
+	if (!raw || typeof raw !== "object") return false;
+	const value = raw as { name?: unknown; _source?: unknown };
+	return typeof value.name === "string" && value._source !== undefined;
+}
+
+export function inferMcpTransport(server: MCPServerDisplay | MCPServerConfigDisplay): "stdio" | "sse" | "http" {
+	if (
+		"transport" in server &&
+		(server.transport === "stdio" || server.transport === "sse" || server.transport === "http")
+	) {
+		return server.transport;
+	}
+	if ("type" in server && (server.type === "stdio" || server.type === "sse" || server.type === "http")) {
+		return server.type;
+	}
+	if ("url" in server && typeof server.url === "string" && server.url.length > 0) {
+		return "http";
+	}
+	return "stdio";
+}
+
+function catalogItem(name: string, title?: string, description?: string, parameters?: unknown): MCPRuntimeCatalogItem {
+	const cleanName = sanitizeDisplayLine(name);
+	const cleanTitle = sanitizeDisplayLineField(title);
+	const cleanDescription = sanitizeDisplayField(description);
+	return {
+		name: cleanName,
+		...(cleanTitle && cleanTitle !== cleanName ? { title: cleanTitle } : {}),
+		...(cleanDescription ? { description: cleanDescription } : {}),
+		...(parameters !== undefined ? { parameters } : {}),
+	};
+}
+
+function toolsFromManager(manager: MCPRuntimeSource, serverName: string): MCPRuntimeCatalogItem[] {
+	const items: MCPRuntimeCatalogItem[] = [];
+	const seen: Record<string, true> = {};
+	for (const tool of manager.getTools()) {
+		if (tool.mcpServerName !== serverName) continue;
+		const name = tool.mcpToolName ?? tool.label?.split("/").pop() ?? tool.label;
+		if (!name || seen[name]) continue;
+		seen[name] = true;
+		items.push(catalogItem(name, undefined, tool.description, tool.parameters));
+	}
+	return items;
+}
+
+function resourcesFrom(connection: MCPConnectionDisplay, manager?: MCPRuntimeSource): MCPRuntimeCatalogItem[] {
+	const listed = manager?.getServerResources?.(connection.name);
+	const resources = listed?.resources ?? connection.resources ?? [];
+	const templates = listed?.templates ?? connection.resourceTemplates ?? [];
+	return [
+		...resources.map(resource => catalogItem(resource.name, resource.title, resource.description ?? resource.uri)),
+		...templates.map(template =>
+			catalogItem(template.name, template.title, template.description ?? template.uriTemplate),
+		),
+	];
+}
+
+function promptsFrom(connection: MCPConnectionDisplay, manager?: MCPRuntimeSource): MCPRuntimeCatalogItem[] {
+	const listed = manager?.getServerPrompts?.(connection.name) ?? connection.prompts ?? [];
+	return listed.map(prompt => catalogItem(prompt.name, prompt.title, prompt.description));
+}
+
+function identityFrom(
+	info: MCPImplementationDisplay | undefined,
+	fallbackName: string,
+): Pick<MCPRuntimeSnapshot, "title" | "description" | "websiteUrl" | "implementationName" | "implementationVersion"> {
+	if (!info) return {};
+	const implementationName = sanitizeDisplayLineField(info.name);
+	const displayTitle = sanitizeDisplayLineField(info.title);
+	return {
+		title: displayTitle && displayTitle !== fallbackName ? displayTitle : undefined,
+		description: sanitizeDisplayField(info.description),
+		websiteUrl: sanitizeDisplayLineField(info.websiteUrl),
+		implementationName,
+		implementationVersion: sanitizeDisplayLineField(info.version),
+	};
+}
+
+export function snapshotMcpRuntime(
+	server: MCPServerDisplay,
+	manager: MCPRuntimeSource | undefined,
+	opts?: { enabled?: boolean; shadowed?: boolean },
+): MCPRuntimeSnapshot {
+	const enabled = opts?.enabled ?? server.enabled !== false;
+	const transport = inferMcpTransport(server);
+	const envCount = server.env ? Object.keys(server.env).length : 0;
+	const base: MCPRuntimeSnapshot = {
+		health: enabled ? "disconnected" : "inactive",
+		transport,
+		command: sanitizeDisplayField(server.command),
+		args: server.args?.map(arg => sanitizeDisplayText(arg)),
+		url: sanitizeDisplayField(server.url),
+		envCount,
+		tools: [],
+		resources: [],
+		prompts: [],
+	};
+
+	// Shadowed same-name configs share a name with the winner. Joining by
+	// server.name would steal the live connection's health/tools/instructions.
+	if (opts?.shadowed || !enabled || !manager) {
+		return base;
+	}
+
+	const health = manager.getConnectionStatus(server.name);
+	const connection = manager.getConnection(server.name);
+	const identity = identityFrom(connection?.serverInfo, server.name);
+	const connectedTools = (connection?.tools ?? []).map(tool =>
+		catalogItem(tool.name, tool.title ?? tool.annotations?.title, tool.description, tool.inputSchema),
+	);
+	const tools = connectedTools.length > 0 ? connectedTools : toolsFromManager(manager, server.name);
+
+	return {
+		...base,
+		health,
+		...identity,
+		instructions: sanitizeDisplayField(connection?.instructions),
+		tools,
+		resources: connection ? resourcesFrom(connection, manager) : [],
+		prompts: connection ? promptsFrom(connection, manager) : [],
+		command:
+			sanitizeDisplayField(server.command) ??
+			(connection?.config && "command" in connection.config
+				? sanitizeDisplayField(connection.config.command)
+				: undefined),
+		args:
+			server.args?.map(arg => sanitizeDisplayText(arg)) ??
+			(connection?.config && "args" in connection.config
+				? connection.config.args?.map(arg => sanitizeDisplayText(arg))
+				: undefined),
+		url:
+			sanitizeDisplayField(server.url) ??
+			(connection?.config && "url" in connection.config ? sanitizeDisplayField(connection.config.url) : undefined),
+		transport: connection ? inferMcpTransport(connection.config) : transport,
+	};
+}
+
+export function formatMcpListHint(snapshot: MCPRuntimeSnapshot): string {
+	switch (snapshot.health) {
+		case "inactive":
+			return "inactive";
+		case "connecting":
+			return "connecting…";
+		case "disconnected":
+			return "unavailable";
+		case "connected": {
+			const parts = [`${snapshot.tools.length} tool${snapshot.tools.length === 1 ? "" : "s"}`];
+			if (snapshot.resources.length > 0) {
+				parts.push(`${snapshot.resources.length} resource${snapshot.resources.length === 1 ? "" : "s"}`);
+			}
+			if (snapshot.prompts.length > 0) {
+				parts.push(`${snapshot.prompts.length} prompt${snapshot.prompts.length === 1 ? "" : "s"}`);
+			}
+			return parts.join(" · ");
+		}
+	}
+}
+
+export function formatMcpHealthLabel(health: MCPConnectionHealth): string {
+	switch (health) {
+		case "connected":
+			return "Connected";
+		case "connecting":
+			return "Connecting";
+		case "disconnected":
+			return "Not connected";
+		case "inactive":
+			return "Inactive";
+	}
+}
+
+export function visibleMcpTools(
+	tools: MCPRuntimeCatalogItem[],
+	limit: number = DEFAULT_VISIBLE_TOOLS,
+): { shown: MCPRuntimeCatalogItem[]; hidden: number } {
+	if (tools.length <= limit) return { shown: tools, hidden: 0 };
+	return { shown: tools.slice(0, limit), hidden: tools.length - limit };
+}

package/src/overlays/extensions/state-manager.ts

@@ -0,0 +1,337 @@
+/** Pure dashboard tree, filtering, and selection state. */
+import { fuzzyMatch } from "../../fuzzy";
+import {
+	type DashboardState,
+	type DisabledReason,
+	type Extension,
+	type ExtensionKind,
+	type ExtensionState,
+	type FlatTreeItem,
+	isShadowedExtension,
+	type ProviderTab,
+	type ExtensionProvider,
+	type TreeNode,
+} from "./types";
+
+export function resolveExtensionState(
+	source: { provider: string; level: string },
+	isDisabled: boolean,
+	isShadowed: boolean | undefined,
+	providers: readonly ExtensionProvider[],
+): { state: ExtensionState; disabledReason?: DisabledReason } {
+	if (isDisabled) return { state: "disabled", disabledReason: "item-disabled" };
+	if (isShadowed) return { state: "shadowed", disabledReason: "shadowed" };
+	if (providers.find(provider => provider.id === source.provider)?.enabled === false)
+		return { state: "disabled", disabledReason: "provider-disabled" };
+	if (
+		source.level === "user" &&
+		providers.find(provider => provider.id === source.provider)?.userSourceEnabled === false
+	) {
+		return { state: "disabled", disabledReason: "user-opt-in" };
+	}
+	return { state: "active" };
+}
+
+/**
+ * Build sidebar tree from extensions.
+ * Groups by provider → kind.
+ */
+export function buildSidebarTree(extensions: Extension[], providers: readonly ExtensionProvider[]): TreeNode[] {
+	const tree: TreeNode[] = [];
+
+	// Group extensions by provider and kind
+	const byProvider = new Map<string, Map<ExtensionKind, Extension[]>>();
+
+	for (const ext of extensions) {
+		const providerId = ext.source.provider;
+		if (!byProvider.has(providerId)) {
+			byProvider.set(providerId, new Map());
+		}
+		const byKind = byProvider.get(providerId)!;
+		if (!byKind.has(ext.kind)) {
+			byKind.set(ext.kind, []);
+		}
+		byKind.get(ext.kind)!.push(ext);
+	}
+
+	// Build tree nodes for each provider (show ALL providers, even if disabled/empty)
+	for (const provider of providers) {
+		// Skip the 'native' provider as it cannot be toggled
+		if (provider.id === "native") continue;
+
+		const byKind = byProvider.get(provider.id);
+		const kindNodes: TreeNode[] = [];
+		let totalCount = 0;
+
+		if (byKind && byKind.size > 0) {
+			for (const [kind, exts] of byKind) {
+				totalCount += exts.length;
+				kindNodes.push({
+					id: `${provider.id}:${kind}`,
+					label: getKindDisplayName(kind),
+					type: "kind",
+					enabled: provider.enabled,
+					collapsed: true,
+					children: [],
+					count: exts.length,
+				});
+			}
+
+			// Sort kind nodes by count (most items first)
+			kindNodes.sort((a, b) => (b.count || 0) - (a.count || 0));
+		}
+
+		tree.push({
+			id: provider.id,
+			label: provider.displayName,
+			type: "provider",
+			enabled: provider.enabled,
+			collapsed: false,
+			children: kindNodes,
+			count: totalCount,
+		});
+	}
+
+	return tree;
+}
+
+/**
+ * Flatten tree for keyboard navigation.
+ */
+export function flattenTree(tree: TreeNode[]): FlatTreeItem[] {
+	const flat: FlatTreeItem[] = [];
+	let index = 0;
+
+	function walk(node: TreeNode, depth: number): void {
+		flat.push({ node, depth, index: index++ });
+		if (!node.collapsed) {
+			for (const child of node.children) {
+				walk(child, depth + 1);
+			}
+		}
+	}
+
+	for (const node of tree) {
+		walk(node, 0);
+	}
+
+	return flat;
+}
+
+/**
+ * Apply fuzzy filter to extensions.
+ */
+export function applyFilter(extensions: Extension[], query: string): Extension[] {
+	if (!query.trim()) {
+		return extensions;
+	}
+
+	const tokens = query.toLowerCase().split(/\s+/).filter(Boolean);
+	if (tokens.length === 0) {
+		return extensions;
+	}
+
+	return extensions.filter(ext => {
+		const searchable = [
+			ext.name,
+			ext.displayName,
+			ext.description || "",
+			ext.trigger || "",
+			ext.source.providerName,
+			ext.kind,
+		].join(" ");
+
+		return tokens.every(token => fuzzyMatch(token, searchable).matches);
+	});
+}
+
+/**
+ * Get display name for extension kind.
+ */
+function getKindDisplayName(kind: ExtensionKind): string {
+	switch (kind) {
+		case "extension-module":
+			return "Extension Modules";
+		case "skill":
+			return "Skills";
+		case "rule":
+			return "Rules";
+		case "tool":
+			return "Tools";
+		case "mcp":
+			return "MCP Servers";
+		case "prompt":
+			return "Prompts";
+		case "instruction":
+			return "Instructions";
+		case "context-file":
+			return "Context Files";
+		case "hook":
+			return "Hooks";
+		case "slash-command":
+			return "Slash Commands";
+		default:
+			return kind;
+	}
+}
+
+/**
+ * Build provider tabs from extensions.
+ */
+export function buildProviderTabs(extensions: Extension[], providers: readonly ExtensionProvider[]): ProviderTab[] {
+	const tabs: ProviderTab[] = [];
+
+	// Count extensions per provider
+	const countByProvider = new Map<string, number>();
+	for (const ext of extensions) {
+		const count = countByProvider.get(ext.source.provider) ?? 0;
+		countByProvider.set(ext.source.provider, count + 1);
+	}
+
+	// ALL tab first
+	tabs.push({
+		id: "all",
+		label: "ALL",
+		enabled: true,
+		count: extensions.length,
+	});
+
+	// Provider tabs (skip native)
+	for (const provider of providers) {
+		if (provider.id === "native") continue;
+		const count = countByProvider.get(provider.id) ?? 0;
+		tabs.push({
+			id: provider.id,
+			label: provider.displayName,
+			enabled: provider.enabled,
+			count,
+		});
+	}
+
+	// Sort: ALL first, then enabled by count, then disabled by count, then empty
+	tabs.sort((a, b) => {
+		if (a.id === "all") return -1;
+		if (b.id === "all") return 1;
+
+		// Categorize: 0 = enabled with content, 1 = disabled, 2 = empty+enabled
+		const category = (t: ProviderTab) => {
+			if (t.count === 0 && t.enabled) return 2; // empty
+			if (!t.enabled) return 1; // disabled
+			return 0; // enabled with content
+		};
+
+		const aCat = category(a);
+		const bCat = category(b);
+		if (aCat !== bCat) return aCat - bCat;
+
+		// Within same category, sort by count descending
+		return b.count - a.count;
+	});
+
+	return tabs;
+}
+
+/**
+ * Filter extensions by provider tab.
+ */
+export function filterByProvider(extensions: Extension[], providerId: string): Extension[] {
+	if (providerId === "all") {
+		return extensions;
+	}
+	return extensions.filter(ext => ext.source.provider === providerId);
+}
+
+/**
+ * Apply setting-backed item disable overrides to an existing dashboard state.
+ * This gives the UI immediate feedback while the full capability refresh runs.
+ */
+export function applyDisabledExtensionsToState(
+	state: DashboardState,
+	disabledIds: string[],
+	providers: readonly ExtensionProvider[] = [],
+): DashboardState {
+	const disabled = new Set(disabledIds);
+	const updateExtension = (ext: Extension): Extension => {
+		if (disabled.has(ext.id)) {
+			if (ext.state === "disabled" && ext.disabledReason === "item-disabled") return ext;
+			return { ...ext, state: "disabled", disabledReason: "item-disabled" };
+		}
+
+		if (ext.state !== "disabled" || ext.disabledReason !== "item-disabled") return ext;
+		const { state, disabledReason } = resolveExtensionState(ext.source, false, isShadowedExtension(ext), providers);
+		if (disabledReason) return { ...ext, state, disabledReason };
+		const enabled: Extension = { ...ext, state };
+		delete enabled.disabledReason;
+		return enabled;
+	};
+
+	return {
+		...state,
+		extensions: state.extensions.map(updateExtension),
+		tabFiltered: state.tabFiltered.map(updateExtension),
+		searchFiltered: state.searchFiltered.map(updateExtension),
+		selected: state.selected ? updateExtension(state.selected) : null,
+	};
+}
+
+/**
+ * Create initial dashboard state.
+ */
+export function createInitialState(extensions: Extension[], providers: readonly ExtensionProvider[]): DashboardState {
+	const tabs = buildProviderTabs(extensions, providers);
+	const tabFiltered = extensions; // "all" tab by default
+	const searchFiltered = tabFiltered;
+
+	return {
+		tabs,
+		activeTabIndex: 0,
+		extensions,
+		tabFiltered,
+		searchFiltered,
+		searchQuery: "",
+		listIndex: 0,
+		scrollOffset: 0,
+		selected: searchFiltered[0] ?? null,
+	};
+}
+
+/**
+ * Refresh state after toggle.
+ */
+export function refreshState(
+	state: DashboardState,
+	extensions: Extension[],
+	providers: readonly ExtensionProvider[],
+): DashboardState {
+	const tabs = buildProviderTabs(extensions, providers);
+
+	// Get current provider from tabs
+	const activeTab = state.tabs[state.activeTabIndex];
+	const providerId = activeTab?.id ?? "all";
+
+	// Re-apply filters
+	const tabFiltered = filterByProvider(extensions, providerId);
+	const searchFiltered = applyFilter(tabFiltered, state.searchQuery);
+
+	// Find new index for current provider (tabs may have reordered)
+	const newActiveTabIndex = tabs.findIndex(t => t.id === providerId);
+	const activeTabIndex = newActiveTabIndex >= 0 ? newActiveTabIndex : 0;
+
+	// Try to preserve selection
+	const selectedId = state.selected?.id;
+	let selected = selectedId ? searchFiltered.find(e => e.id === selectedId) : null;
+	if (!selected && searchFiltered.length > 0) {
+		selected = searchFiltered[Math.min(state.listIndex, searchFiltered.length - 1)];
+	}
+
+	return {
+		...state,
+		tabs,
+		activeTabIndex,
+		extensions,
+		tabFiltered,
+		searchFiltered,
+		selected: selected ?? null,
+		listIndex: selected ? searchFiltered.indexOf(selected) : 0,
+	};
+}