miladyai 2.0.0-alpha.27

package/dist/tui/components/plugins-overlay-catalog.js

@@ -0,0 +1,81 @@
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+
+//#region src/tui/components/plugins-overlay-catalog.ts
+let pluginCatalogCache = null;
+function inferSensitiveKey(key) {
+	const upper = key.toUpperCase();
+	return upper.includes("_API_KEY") || upper.includes("_SECRET") || upper.includes("_TOKEN") || upper.includes("_PASSWORD") || upper.includes("_PRIVATE_KEY") || upper.includes("_SIGNING_") || upper.includes("ENCRYPTION_");
+}
+function inferRequiredKey(key, sensitive) {
+	if (!sensitive) return false;
+	const upper = key.toUpperCase();
+	return upper.endsWith("_API_KEY") || upper.endsWith("_BOT_TOKEN") || upper.endsWith("_TOKEN") || upper.endsWith("_PRIVATE_KEY");
+}
+function findPackageRoot(startDir) {
+	let dir = startDir;
+	for (let i = 0; i < 10; i++) {
+		const pkgPath = path.join(dir, "package.json");
+		if (fs.existsSync(pkgPath)) try {
+			if (JSON.parse(fs.readFileSync(pkgPath, "utf-8")).name === "milady") return dir;
+		} catch {}
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return startDir;
+}
+function buildPluginCatalogIndex() {
+	if (pluginCatalogCache) return pluginCatalogCache;
+	const packageRoot = findPackageRoot(import.meta.dirname ?? path.dirname(fileURLToPath(import.meta.url)));
+	const manifestPath = path.join(packageRoot, "plugins.json");
+	const map = /* @__PURE__ */ new Map();
+	if (!fs.existsSync(manifestPath)) {
+		pluginCatalogCache = map;
+		return map;
+	}
+	try {
+		const data = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+		for (const entry of data.plugins ?? []) {
+			map.set(entry.id, entry);
+			if (entry.npmName) map.set(entry.npmName, entry);
+			if (entry.id.startsWith("plugin-")) map.set(`@elizaos/${entry.id}`, entry);
+			else {
+				map.set(`plugin-${entry.id}`, entry);
+				map.set(`@elizaos/plugin-${entry.id}`, entry);
+			}
+		}
+	} catch {}
+	pluginCatalogCache = map;
+	return map;
+}
+function readInstalledPluginMetadata(packageName, installPath) {
+	if (!installPath) return {
+		configKeys: [],
+		pluginParameters: {},
+		configUiHints: {}
+	};
+	const pkgJsonCandidates = [path.join(installPath, "node_modules", ...packageName.split("/"), "package.json"), path.join(installPath, "package.json")];
+	for (const pkgPath of pkgJsonCandidates) {
+		if (!fs.existsSync(pkgPath)) continue;
+		try {
+			const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+			const pluginParameters = pkg.pluginParameters ?? pkg.elizaos?.pluginParameters ?? pkg.agentConfig?.pluginParameters ?? {};
+			const configUiHints = pkg.configUiHints ?? pkg.elizaos?.configUiHints ?? {};
+			return {
+				configKeys: Array.from(new Set([...pkg.elizaos?.configKeys ?? [], ...Object.keys(pluginParameters)])),
+				pluginParameters,
+				configUiHints
+			};
+		} catch {}
+	}
+	return {
+		configKeys: [],
+		pluginParameters: {},
+		configUiHints: {}
+	};
+}
+
+//#endregion
+export { buildPluginCatalogIndex, inferRequiredKey, inferSensitiveKey, readInstalledPluginMetadata };

package/dist/tui/components/plugins-overlay-data-api.js

@@ -0,0 +1,21 @@
+//#region src/tui/components/plugins-overlay-data-api.ts
+async function installPluginViaApiRequest(request, name) {
+	const response = await request("/api/plugins/install", {
+		method: "POST",
+		body: JSON.stringify({ name })
+	});
+	if (!response.ok) return {
+		success: false,
+		message: response.error ?? `Failed to install ${name}`
+	};
+	const pluginName = response.plugin?.name ?? name;
+	const version = response.plugin?.version;
+	const restartHint = response.requiresRestart ? " Restart milady to load it." : "";
+	return {
+		success: true,
+		message: response.message ?? `${pluginName}${version ? `@${version}` : ""} installed.${restartHint}`
+	};
+}
+
+//#endregion
+export { installPluginViaApiRequest };

package/dist/tui/components/plugins-overlay-data-shared.js

@@ -0,0 +1,20 @@
+//#region src/tui/components/plugins-overlay-data-shared.ts
+const API_MASKED_SENTINEL = "__MILADY_API_MASKED__";
+function registerPluginNameVariants(names, rawName) {
+	const trimmed = rawName.trim();
+	if (!trimmed) return;
+	names.add(trimmed);
+	const normalized = trimmed.replace(/^@[^/]+\//, "").replace(/^plugin-/, "").trim();
+	if (!normalized) return;
+	names.add(normalized);
+	names.add(`plugin-${normalized}`);
+	names.add(`@elizaos/plugin-${normalized}`);
+}
+function matchesInstalledPluginName(candidates, installedName) {
+	if (candidates.has(installedName)) return true;
+	const normalized = installedName.replace(/^@[^/]+\//, "").replace(/^plugin-/, "").trim();
+	return normalized.length > 0 && candidates.has(normalized);
+}
+
+//#endregion
+export { API_MASKED_SENTINEL, matchesInstalledPluginName, registerPluginNameVariants };

package/dist/tui/components/plugins-overlay-data.js

@@ -0,0 +1,323 @@
+import { loadMiladyConfig, saveMiladyConfig } from "../../config/config.js";
+import { getRegistryPlugins } from "../../services/registry-client.js";
+import { installPlugin } from "../../services/plugin-installer.js";
+import { buildPluginCatalogIndex, inferRequiredKey, inferSensitiveKey, readInstalledPluginMetadata } from "./plugins-overlay-catalog.js";
+import { installPluginViaApiRequest } from "./plugins-overlay-data-api.js";
+import { API_MASKED_SENTINEL, matchesInstalledPluginName, registerPluginNameVariants } from "./plugins-overlay-data-shared.js";
+
+//#region src/tui/components/plugins-overlay-data.ts
+var PluginsOverlayDataBridge = class {
+	constructor(options) {
+		this.options = options;
+		this.apiInstalledPluginNames = /* @__PURE__ */ new Set();
+	}
+	getApiBaseUrl() {
+		const base = this.options.apiBaseUrl?.trim() || process.env.MILADY_API_BASE_URL?.trim() || process.env.MILADY_API_BASE?.trim();
+		if (!base) return null;
+		return base.replace(/\/+$/, "");
+	}
+	getApiToken() {
+		const token = process.env.MILADY_API_TOKEN?.trim();
+		return token ? token : null;
+	}
+	async apiFetchJson(apiBaseUrl, routePath, init) {
+		const headers = new Headers(init?.headers);
+		if (init?.body != null && !headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+		const token = this.getApiToken();
+		if (token && !headers.has("Authorization")) headers.set("Authorization", `Bearer ${token}`);
+		const res = await fetch(`${apiBaseUrl}${routePath}`, {
+			...init,
+			headers
+		});
+		if (!res.ok) {
+			let message = `HTTP ${res.status}`;
+			try {
+				const body = await res.json();
+				if (typeof body.error === "string" && body.error.trim()) message = body.error;
+				else if (Array.isArray(body.validationErrors)) {
+					const first = body.validationErrors[0];
+					if (first?.message) message = first.message;
+				}
+			} catch {}
+			throw new Error(message);
+		}
+		return res.json();
+	}
+	async getInstalledPlugins() {
+		const apiBaseUrl = this.getApiBaseUrl();
+		if (apiBaseUrl) try {
+			return await this.getInstalledPluginsFromApi(apiBaseUrl);
+		} catch {}
+		return this.getInstalledPluginsFromConfig();
+	}
+	registerInstalledPluginName(name) {
+		registerPluginNameVariants(this.apiInstalledPluginNames, name);
+	}
+	async loadApiInstalledPlugins(apiBaseUrl) {
+		try {
+			const plugins = (await this.apiFetchJson(apiBaseUrl, "/api/plugins/installed")).plugins ?? [];
+			this.apiInstalledPluginNames.clear();
+			for (const plugin of plugins) if (plugin.name) this.registerInstalledPluginName(plugin.name);
+			return plugins;
+		} catch {
+			return [];
+		}
+	}
+	async getInstalledPluginsFromApi(apiBaseUrl) {
+		const installed = await this.loadApiInstalledPlugins(apiBaseUrl);
+		let response;
+		try {
+			response = await this.apiFetchJson(apiBaseUrl, "/api/plugins");
+		} catch (err) {
+			if (installed.length === 0) throw err;
+			const fallbackItems = [];
+			for (const plugin of installed) {
+				const name = plugin.name?.trim();
+				if (!name) continue;
+				const id = name.replace(/^@[^/]+\//, "").replace(/^plugin-/, "");
+				fallbackItems.push({
+					id: id || name,
+					name,
+					description: "",
+					enabled: true,
+					category: "plugin",
+					version: plugin.version ?? "unknown",
+					configStatus: {
+						set: 0,
+						total: 0
+					},
+					parameters: []
+				});
+			}
+			return fallbackItems;
+		}
+		const plugins = response.plugins ?? [];
+		const matchedInstalled = /* @__PURE__ */ new Set();
+		const items = plugins.map((plugin) => {
+			const pluginId = plugin.id?.trim() || plugin.name?.trim() || "plugin";
+			const npmName = plugin.npmName?.trim();
+			if (npmName) this.registerInstalledPluginName(npmName);
+			if (pluginId) this.registerInstalledPluginName(pluginId);
+			const candidates = /* @__PURE__ */ new Set();
+			if (pluginId) {
+				candidates.add(pluginId);
+				candidates.add(`plugin-${pluginId}`);
+				candidates.add(`@elizaos/plugin-${pluginId}`);
+			}
+			if (npmName) candidates.add(npmName);
+			let installedVersion;
+			for (const entry of installed) {
+				const installedName = entry.name?.trim();
+				if (!installedName) continue;
+				if (!matchesInstalledPluginName(candidates, installedName)) continue;
+				matchedInstalled.add(installedName);
+				installedVersion = entry.version ?? installedVersion;
+			}
+			const parameters = (plugin.parameters ?? []).map((param) => {
+				const key = param.key;
+				const hint = plugin.configUiHints?.[key];
+				const options = Array.isArray(hint?.options) ? hint.options.map((opt) => {
+					if (typeof opt === "string") return opt;
+					if (typeof opt === "object" && opt !== null) {
+						const value = opt.value;
+						if (typeof value === "string") return value;
+					}
+					return null;
+				}).filter((v) => typeof v === "string") : void 0;
+				return {
+					key,
+					label: typeof hint?.label === "string" && hint.label.trim() ? hint.label : key,
+					value: param.sensitive && param.isSet ? API_MASKED_SENTINEL : param.currentValue ?? "",
+					required: param.required,
+					sensitive: param.sensitive,
+					values: options
+				};
+			});
+			return {
+				id: pluginId,
+				name: plugin.name || pluginId,
+				description: plugin.description ?? "",
+				enabled: plugin.enabled !== false,
+				category: plugin.category ?? "plugin",
+				version: plugin.version ?? installedVersion ?? "unknown",
+				configStatus: {
+					set: (plugin.parameters ?? []).filter((p) => p.isSet).length,
+					total: (plugin.parameters ?? []).length
+				},
+				parameters
+			};
+		});
+		for (const entry of installed) {
+			const installedName = entry.name?.trim();
+			if (!installedName || matchedInstalled.has(installedName)) continue;
+			const id = installedName.replace(/^@[^/]+\//, "").replace(/^plugin-/, "").trim();
+			items.push({
+				id: id || installedName,
+				name: installedName,
+				description: "",
+				enabled: true,
+				category: "plugin",
+				version: entry.version ?? "unknown",
+				configStatus: {
+					set: 0,
+					total: 0
+				},
+				parameters: []
+			});
+		}
+		return items;
+	}
+	async getInstalledPluginsFromConfig() {
+		const cfg = loadMiladyConfig();
+		const entries = cfg.plugins?.entries ?? {};
+		const installs = cfg.plugins?.installs ?? {};
+		const catalog = buildPluginCatalogIndex();
+		const plugins = [];
+		const allIds = new Set([...Object.keys(entries), ...Object.keys(installs)]);
+		for (const id of allIds) {
+			const entry = entries[id];
+			const install = installs[id];
+			const config = entry?.config ?? {};
+			const catalogEntry = catalog.get(id);
+			const installedMeta = readInstalledPluginMetadata(id, install?.installPath);
+			const mergedParamDefs = {
+				...catalogEntry?.pluginParameters ?? {},
+				...installedMeta.pluginParameters
+			};
+			const mergedHints = {
+				...catalogEntry?.configUiHints ?? {},
+				...installedMeta.configUiHints
+			};
+			const declaredKeys = [
+				...catalogEntry?.configKeys ?? [],
+				...installedMeta.configKeys,
+				...Object.keys(mergedParamDefs)
+			];
+			const keySet = new Set([...declaredKeys, ...Object.keys(config)]);
+			const parameters = Array.from(keySet).sort((a, b) => a.localeCompare(b)).map((key) => {
+				const valueFromConfig = config[key];
+				const value = valueFromConfig != null && valueFromConfig !== "" ? String(valueFromConfig) : process.env[key] ?? "";
+				const hint = mergedHints[key];
+				const paramDef = mergedParamDefs[key];
+				const sensitive = typeof paramDef?.sensitive === "boolean" ? paramDef.sensitive : inferSensitiveKey(key);
+				const required = typeof paramDef?.required === "boolean" ? paramDef.required : inferRequiredKey(key, sensitive);
+				return {
+					key,
+					label: hint?.label ?? key,
+					value,
+					required,
+					sensitive
+				};
+			});
+			plugins.push({
+				id,
+				name: id,
+				description: install?.spec ?? catalogEntry?.description ?? "",
+				enabled: entry?.enabled !== false,
+				category: id.includes("plugin-") ? "plugin" : "extension",
+				version: install?.version ?? "unknown",
+				configStatus: {
+					set: parameters.filter((p) => p.value.trim() !== "").length,
+					total: parameters.length
+				},
+				parameters
+			});
+		}
+		return plugins;
+	}
+	async togglePluginEnabled(id, enabled) {
+		const apiBaseUrl = this.getApiBaseUrl();
+		if (apiBaseUrl) {
+			await this.apiFetchJson(apiBaseUrl, `/api/plugins/${encodeURIComponent(id)}`, {
+				method: "PUT",
+				body: JSON.stringify({ enabled })
+			});
+			return;
+		}
+		const cfg = loadMiladyConfig();
+		if (!cfg.plugins) cfg.plugins = {};
+		if (!cfg.plugins.entries) cfg.plugins.entries = {};
+		if (!cfg.plugins.entries[id]) cfg.plugins.entries[id] = {};
+		cfg.plugins.entries[id].enabled = enabled;
+		saveMiladyConfig(cfg);
+	}
+	async savePluginConfig(id, config) {
+		const apiBaseUrl = this.getApiBaseUrl();
+		if (apiBaseUrl) {
+			const filteredConfig = Object.fromEntries(Object.entries(config).filter(([, value]) => value !== API_MASKED_SENTINEL));
+			await this.apiFetchJson(apiBaseUrl, `/api/plugins/${encodeURIComponent(id)}`, {
+				method: "PUT",
+				body: JSON.stringify({ config: filteredConfig })
+			});
+			return;
+		}
+		const cfg = loadMiladyConfig();
+		if (!cfg.plugins) cfg.plugins = {};
+		if (!cfg.plugins.entries) cfg.plugins.entries = {};
+		if (!cfg.plugins.entries[id]) cfg.plugins.entries[id] = {};
+		cfg.plugins.entries[id].config = config;
+		saveMiladyConfig(cfg);
+	}
+	async installPlugin(name) {
+		const apiBaseUrl = this.getApiBaseUrl();
+		if (apiBaseUrl) return installPluginViaApiRequest((routePath, init) => this.apiFetchJson(apiBaseUrl, routePath, init), name);
+		const result = await installPlugin(name);
+		if (!result.success) return {
+			success: false,
+			message: result.error ?? `Failed to install ${name}`
+		};
+		const restartHint = result.requiresRestart ? " Restart milady to load it." : "";
+		return {
+			success: true,
+			message: `${result.pluginName}@${result.version} installed.${restartHint}`
+		};
+	}
+	async getStorePlugins() {
+		const apiBaseUrl = this.getApiBaseUrl();
+		if (apiBaseUrl) await this.loadApiInstalledPlugins(apiBaseUrl);
+		const registry = await getRegistryPlugins();
+		const installs = loadMiladyConfig().plugins?.installs ?? {};
+		const items = [];
+		for (const [, p] of registry) {
+			if (p.kind === "app") continue;
+			items.push({
+				name: p.name,
+				description: p.description,
+				latestVersion: p.npm.v2Version || p.npm.v1Version || p.npm.v0Version,
+				stars: p.stars,
+				supports: p.supports,
+				installed: this.isPluginInstalled(p.name) || p.name in installs
+			});
+		}
+		items.sort((a, b) => b.stars - a.stars);
+		return items;
+	}
+	async searchStore(query, limit = 15) {
+		const apiBaseUrl = this.getApiBaseUrl();
+		if (apiBaseUrl) await this.loadApiInstalledPlugins(apiBaseUrl);
+		const { searchNonAppPlugins } = await import("../../services/registry-client.js");
+		const results = await searchNonAppPlugins(query, limit);
+		const installs = loadMiladyConfig().plugins?.installs ?? {};
+		return results.map((r) => ({
+			name: r.name,
+			description: r.description,
+			latestVersion: r.latestVersion,
+			stars: r.stars,
+			supports: r.supports,
+			installed: this.isPluginInstalled(r.name) || r.name in installs
+		}));
+	}
+	isPluginInstalled(name) {
+		if (this.apiInstalledPluginNames.has(name)) return true;
+		const normalized = name.replace(/^@[^/]+\//, "").replace(/^plugin-/, "");
+		if (normalized && this.apiInstalledPluginNames.has(normalized)) return true;
+		try {
+			return name in (loadMiladyConfig().plugins?.installs ?? {});
+		} catch {
+			return false;
+		}
+	}
+};
+
+//#endregion
+export { PluginsOverlayDataBridge };

package/dist/tui/components/plugins-overlay.js

@@ -0,0 +1,117 @@
+import { addRegistryEndpoint, getConfiguredEndpoints, isDefaultEndpoint, removeRegistryEndpoint, toggleRegistryEndpoint } from "../../services/registry-client.js";
+import { tuiTheme } from "../theme.js";
+import { ModalFrame } from "./modal-frame.js";
+import { PluginEndpointsTab } from "./plugins-endpoints-tab.js";
+import { InstalledPluginsTab } from "./plugins-installed-tab.js";
+import { PluginsOverlayDataBridge } from "./plugins-overlay-data.js";
+import { PluginStoreTab } from "./plugins-store-tab.js";
+import { getEditorKeybindings } from "@mariozechner/pi-tui";
+
+//#region src/tui/components/plugins-overlay.ts
+const TAB_NAMES = [
+	"Installed",
+	"Store",
+	"Endpoints"
+];
+/**
+* Main Plugins overlay with three tabs: Installed, Store, Endpoints.
+* Accessible via `/plugins` or Ctrl+L.
+*/
+var PluginsOverlayComponent = class {
+	constructor(options) {
+		this.options = options;
+		this.focused = false;
+		this.activeTab = 0;
+		this.frame = new ModalFrame({
+			title: "Plugins",
+			hint: "↑↓ navigate • Tab switch tabs • Enter select • Esc close"
+		});
+		this.data = new PluginsOverlayDataBridge(options);
+		const render = () => options.requestRender();
+		this.tabs = [
+			new InstalledPluginsTab({
+				getPlugins: () => this.data.getInstalledPlugins(),
+				onTogglePlugin: async (id, enabled) => {
+					await this.data.togglePluginEnabled(id, enabled);
+				},
+				onConfigSave: async (id, config) => {
+					await this.data.savePluginConfig(id, config);
+				},
+				onClose: () => options.onClose(),
+				requestRender: render
+			}),
+			new PluginStoreTab({
+				searchPlugins: async (query, limit) => this.data.searchStore(query, limit),
+				getRegistryPlugins: async () => this.data.getStorePlugins(),
+				installPlugin: async (name) => this.data.installPlugin(name),
+				isInstalled: (name) => this.data.isPluginInstalled(name),
+				onClose: () => options.onClose(),
+				requestRender: render
+			}),
+			new PluginEndpointsTab({
+				getEndpoints: () => getConfiguredEndpoints(),
+				addEndpoint: (label, url) => addRegistryEndpoint(label, url),
+				removeEndpoint: (url) => removeRegistryEndpoint(url),
+				toggleEndpoint: (url, enabled) => toggleRegistryEndpoint(url, enabled),
+				isDefaultEndpoint: (url) => isDefaultEndpoint(url),
+				onClose: () => options.onClose(),
+				requestRender: render
+			})
+		];
+	}
+	switchTab(index) {
+		this.activeTab = index;
+		this.options.requestRender();
+	}
+	handleInput(data) {
+		const kb = getEditorKeybindings();
+		const tab = this.tabs[this.activeTab];
+		tab.focused = this.focused;
+		if (tab.isCapturingInput()) {
+			tab.handleInput(data);
+			return;
+		}
+		if (kb.matches(data, "selectCancel")) {
+			this.options.onClose();
+			return;
+		}
+		if (data === "	") {
+			this.switchTab((this.activeTab + 1) % 3);
+			return;
+		}
+		if (data === "1") {
+			this.switchTab(0);
+			return;
+		}
+		if (data === "2") {
+			this.switchTab(1);
+			return;
+		}
+		if (data === "3") {
+			this.switchTab(2);
+			return;
+		}
+		tab.handleInput(data);
+	}
+	render(width) {
+		const body = [];
+		const tabBar = TAB_NAMES.map((name, i) => {
+			const isActive = i === this.activeTab;
+			const num = `${i + 1}`;
+			if (isActive) return tuiTheme.accent(`[${num}:${name}]`);
+			return tuiTheme.dim(` ${num}:${name} `);
+		}).join("  ");
+		body.push(` ${tabBar}`);
+		body.push("");
+		const tab = this.tabs[this.activeTab];
+		tab.focused = this.focused;
+		body.push(...tab.render(width));
+		return this.frame.render(width, body);
+	}
+	invalidate() {
+		for (const tab of this.tabs) tab.invalidate();
+	}
+};
+
+//#endregion
+export { PluginsOverlayComponent };