miladyai 2.0.0-alpha.27

package/dist/tui/components/pinned-chat-layout.js

@@ -0,0 +1,46 @@
+//#region src/tui/components/pinned-chat-layout.ts
+/**
+* Keeps the bottom UI chrome (status + editor + footer) pinned to the terminal
+* bottom while showing the most recent chat lines above it.
+*/
+var PinnedChatLayout = class {
+	constructor(options) {
+		this.options = options;
+	}
+	render(width) {
+		const rows = Math.max(1, this.options.getTerminalRows());
+		const chatLines = this.options.chat.render(width);
+		const ephemeralLines = this.options.ephemeralStatus.render(width);
+		const statusLines = this.options.statusBar.render(width);
+		const editorLines = this.options.editor.render(width);
+		const footerLines = this.options.footer.render(width);
+		const spacerCount = Math.max(0, this.options.spacerLines ?? 1);
+		const spacerLines = Array.from({ length: spacerCount }, () => "");
+		const bottomLines = [
+			...ephemeralLines,
+			...statusLines,
+			...spacerLines,
+			...editorLines,
+			...footerLines
+		];
+		if (bottomLines.length >= rows) return bottomLines.slice(bottomLines.length - rows);
+		const chatBudget = rows - bottomLines.length;
+		const visibleChat = chatLines.length > chatBudget ? chatLines.slice(chatLines.length - chatBudget) : chatLines;
+		const padding = Array.from({ length: Math.max(0, chatBudget - visibleChat.length) }, () => "");
+		return [
+			...visibleChat,
+			...padding,
+			...bottomLines
+		];
+	}
+	invalidate() {
+		this.options.chat.invalidate?.();
+		this.options.ephemeralStatus.invalidate?.();
+		this.options.statusBar.invalidate?.();
+		this.options.editor.invalidate?.();
+		this.options.footer.invalidate?.();
+	}
+};
+
+//#endregion
+export { PinnedChatLayout };

package/dist/tui/components/plugins-endpoints-tab.js

@@ -0,0 +1,196 @@
+import { tuiTheme } from "../theme.js";
+import chalk from "chalk";
+import { Input, SettingsList, getEditorKeybindings } from "@mariozechner/pi-tui";
+
+//#region src/tui/components/plugins-endpoints-tab.ts
+const endpointsListTheme = {
+	label: (text, selected) => selected ? tuiTheme.accent(text) : text,
+	value: (text, selected) => selected ? tuiTheme.accent(text) : tuiTheme.muted(text),
+	description: (text) => tuiTheme.dim(text),
+	cursor: tuiTheme.accent("→ "),
+	hint: (text) => tuiTheme.dim(text)
+};
+/**
+* Endpoints tab — manage plugin registry endpoint URLs.
+* Default endpoint is shown with [default] badge and cannot be removed.
+*/
+var PluginEndpointsTab = class {
+	constructor(options) {
+		this.focused = false;
+		this.state = "list";
+		this.labelInput = new Input();
+		this.urlInput = new Input();
+		this.pendingLabel = "";
+		this.deleteUrl = "";
+		this.lastInteractedId = "";
+		this.endpointIds = [];
+		this.selectedIdx = 0;
+		this.options = options;
+		this.rebuildList();
+	}
+	/** Whether the tab is in an input-consuming state (add/delete flows). */
+	isCapturingInput() {
+		return this.state !== "list";
+	}
+	rebuildList() {
+		const endpoints = this.options.getEndpoints();
+		const items = [];
+		this.endpointIds = [];
+		items.push({
+			id: "__default__",
+			label: "ElizaOS Registry [default]",
+			currentValue: "always on",
+			values: ["always on"]
+		});
+		this.endpointIds.push("__default__");
+		for (const ep of endpoints) {
+			const enabled = ep.enabled !== false;
+			items.push({
+				id: ep.url,
+				label: `${ep.label}`,
+				description: ep.url,
+				currentValue: enabled ? "on" : "off",
+				values: ["on", "off"]
+			});
+			this.endpointIds.push(ep.url);
+		}
+		this.settingsList = new SettingsList(items, 12, endpointsListTheme, (id, newValue) => {
+			this.lastInteractedId = id;
+			if (id === "__default__") return;
+			this.options.toggleEndpoint(id, newValue === "on");
+			this.rebuildList();
+			this.options.requestRender();
+		}, () => this.options.onClose());
+	}
+	handleInput(data) {
+		const kb = getEditorKeybindings();
+		switch (this.state) {
+			case "list": {
+				const kb2 = getEditorKeybindings();
+				if (kb2.matches(data, "selectUp")) {
+					this.selectedIdx = Math.max(0, this.selectedIdx - 1);
+					this.lastInteractedId = this.endpointIds[this.selectedIdx] ?? "";
+				} else if (kb2.matches(data, "selectDown")) {
+					this.selectedIdx = Math.min(this.endpointIds.length - 1, this.selectedIdx + 1);
+					this.lastInteractedId = this.endpointIds[this.selectedIdx] ?? "";
+				}
+				if (data === "a") {
+					this.state = "add-label";
+					this.labelInput.setValue("");
+					this.options.requestRender();
+					return;
+				}
+				if (data === "d") {
+					if (this.lastInteractedId && this.lastInteractedId !== "__default__" && !this.options.isDefaultEndpoint(this.lastInteractedId)) {
+						this.deleteUrl = this.lastInteractedId;
+						this.state = "confirm-delete";
+						this.options.requestRender();
+						return;
+					}
+					return;
+				}
+				this.settingsList.handleInput(data);
+				break;
+			}
+			case "add-label":
+				if (kb.matches(data, "selectCancel")) {
+					this.state = "list";
+					this.options.requestRender();
+					return;
+				}
+				if (data === "\r" || data === "\n") {
+					const label = this.labelInput.getValue().trim();
+					if (label) {
+						this.pendingLabel = label;
+						this.state = "add-url";
+						this.urlInput.setValue("");
+						this.options.requestRender();
+					}
+					return;
+				}
+				this.labelInput.handleInput(data);
+				break;
+			case "add-url":
+				if (kb.matches(data, "selectCancel")) {
+					this.state = "list";
+					this.options.requestRender();
+					return;
+				}
+				if (data === "\r" || data === "\n") {
+					const url = this.urlInput.getValue().trim();
+					if (url) {
+						try {
+							this.options.addEndpoint(this.pendingLabel, url);
+							this.rebuildList();
+						} catch (_err) {}
+						this.state = "list";
+						this.options.requestRender();
+					}
+					return;
+				}
+				this.urlInput.handleInput(data);
+				break;
+			case "confirm-delete":
+				if (data === "y" || data === "Y") {
+					try {
+						this.options.removeEndpoint(this.deleteUrl);
+						this.rebuildList();
+					} catch {}
+					this.state = "list";
+					this.options.requestRender();
+					return;
+				}
+				if (data === "n" || data === "N" || kb.matches(data, "selectCancel")) {
+					this.state = "list";
+					this.options.requestRender();
+					return;
+				}
+				break;
+		}
+	}
+	render(width) {
+		switch (this.state) {
+			case "add-label":
+				this.labelInput.focused = this.focused;
+				return [
+					chalk.bold("  Add Registry Endpoint"),
+					"",
+					"  Label:",
+					...this.labelInput.render(width).map((l) => `    ${l}`),
+					"",
+					tuiTheme.dim("  Enter to continue • Esc to cancel")
+				];
+			case "add-url":
+				this.urlInput.focused = this.focused;
+				return [
+					chalk.bold("  Add Registry Endpoint"),
+					"",
+					`  Label: ${tuiTheme.accent(this.pendingLabel)}`,
+					"  URL:",
+					...this.urlInput.render(width).map((l) => `    ${l}`),
+					"",
+					tuiTheme.dim("  Enter to save • Esc to cancel")
+				];
+			case "confirm-delete": return [
+				"",
+				`  ${tuiTheme.warning("Delete endpoint?")}`,
+				`  ${tuiTheme.dim(this.deleteUrl)}`,
+				"",
+				`  ${tuiTheme.accent("y")} to confirm • ${tuiTheme.accent("n")} to cancel`
+			];
+			default: return [
+				...this.settingsList.render(width),
+				"",
+				tuiTheme.dim("  ↑↓ navigate • Enter/Space toggle • a add • d delete • Esc close")
+			];
+		}
+	}
+	invalidate() {
+		this.settingsList.invalidate();
+		this.labelInput.invalidate();
+		this.urlInput.invalidate();
+	}
+};
+
+//#endregion
+export { PluginEndpointsTab };

package/dist/tui/components/plugins-installed-tab-view.js

@@ -0,0 +1,69 @@
+import { tuiTheme } from "../theme.js";
+
+//#region src/tui/components/plugins-installed-tab-view.ts
+function formatSettingValue(value, showUnmaskedValues) {
+	if (value === "") return tuiTheme.dim("(empty)");
+	if (showUnmaskedValues) return value;
+	return tuiTheme.muted("•".repeat(Math.max(8, Math.min(24, value.length))));
+}
+function renderEditSelectView(params) {
+	const { editingPluginName, editingKeys, editingIndex, editingDraft, editingParamsByKey, showUnmaskedValues } = params;
+	const lines = [];
+	lines.push(`  ${tuiTheme.accent("Edit Plugin Settings")}`);
+	lines.push(`  ${tuiTheme.dim(editingPluginName)}`);
+	lines.push("");
+	if (editingKeys.length === 0) {
+		lines.push(tuiTheme.dim("  No settings yet. Press 'a' to add one."));
+		lines.push("");
+		lines.push(tuiTheme.dim("  a add setting • s save • Esc cancel"));
+		return lines;
+	}
+	const labels = editingKeys.map((key) => {
+		const param = editingParamsByKey[key];
+		const requiredBadge = param?.required ? " *" : "";
+		return `${param?.label ?? key}${requiredBadge}`;
+	});
+	const maxLabelWidth = Math.max(...labels.map((label) => label.length));
+	editingKeys.forEach((key, idx) => {
+		const selected = idx === editingIndex;
+		const value = editingDraft[key] ?? "";
+		const cursor = selected ? tuiTheme.accent("→") : " ";
+		const label = (labels[idx] ?? key).padEnd(maxLabelWidth);
+		const renderedValue = formatSettingValue(value, showUnmaskedValues);
+		const line = `${cursor} ${selected ? tuiTheme.accent(label) : label}  ${renderedValue}`;
+		lines.push(`  ${line}`);
+	});
+	lines.push("");
+	lines.push(tuiTheme.dim("  * required"));
+	lines.push(tuiTheme.dim(`  ↑↓ select setting • Enter edit value • a add • s save • Ctrl+U ${showUnmaskedValues ? "mask" : "unmask"} • Esc cancel`));
+	return lines;
+}
+function renderAddKeyView(params) {
+	const { width, focused, editingPluginName, newKeyInput } = params;
+	newKeyInput.focused = focused;
+	return [
+		`  ${tuiTheme.accent("Add Setting Key")}`,
+		`  ${tuiTheme.dim(editingPluginName)}`,
+		"",
+		...newKeyInput.render(width).map((line) => `  ${line}`),
+		"",
+		tuiTheme.dim("  Enter continue • Esc back")
+	];
+}
+function renderEditValueView(params) {
+	const { width, focused, editingPluginName, editingKeys, editingIndex, showUnmaskedValues, valueInput } = params;
+	const key = editingKeys[editingIndex] ?? "";
+	valueInput.focused = focused;
+	const valueLines = showUnmaskedValues ? valueInput.render(width).map((line) => `  ${line}`) : [`  ${tuiTheme.accent("→")} ${tuiTheme.muted("•".repeat(valueInput.getValue().length))}`];
+	return [
+		`  ${tuiTheme.accent("Edit Value")}`,
+		`  ${tuiTheme.dim(`${editingPluginName} • ${key}`)}`,
+		"",
+		...valueLines,
+		"",
+		tuiTheme.dim(`  Enter apply • Ctrl+U ${showUnmaskedValues ? "mask" : "unmask"} • Esc back`)
+	];
+}
+
+//#endregion
+export { renderAddKeyView, renderEditSelectView, renderEditValueView };

package/dist/tui/components/plugins-installed-tab.js

@@ -0,0 +1,319 @@
+import { tuiTheme } from "../theme.js";
+import { renderAddKeyView, renderEditSelectView, renderEditValueView } from "./plugins-installed-tab-view.js";
+import { Input, SelectList, getEditorKeybindings, matchesKey } from "@mariozechner/pi-tui";
+
+//#region src/tui/components/plugins-installed-tab.ts
+/**
+* Installed Plugins tab — filterable list of installed/loaded plugins with
+* enable/disable toggle and per-plugin configuration.
+*/
+var InstalledPluginsTab = class {
+	constructor(options) {
+		this.focused = false;
+		this.filterInput = new Input();
+		this.pluginsById = /* @__PURE__ */ new Map();
+		this.allItems = [];
+		this.loading = true;
+		this.state = "list";
+		this.editingPluginId = null;
+		this.editingPluginName = "";
+		this.editingKeys = [];
+		this.editingParamsByKey = {};
+		this.editingDraft = {};
+		this.editingIndex = 0;
+		this.valueInput = new Input();
+		this.newKeyInput = new Input();
+		this.showUnmaskedValues = false;
+		this.statusMessage = "";
+		this.options = options;
+		this.selectList = new SelectList([], 14, tuiTheme.selectList);
+		this.selectList.onCancel = () => options.onClose();
+		this.filterInput.setValue("");
+		this.loadPlugins();
+	}
+	/** Whether the tab is in an input-consuming state. */
+	isCapturingInput() {
+		return this.state !== "list";
+	}
+	async loadPlugins() {
+		this.loading = true;
+		this.options.requestRender();
+		try {
+			const plugins = await this.options.getPlugins();
+			plugins.sort((a, b) => {
+				if (a.enabled !== b.enabled) return a.enabled ? -1 : 1;
+				return a.name.localeCompare(b.name);
+			});
+			this.pluginsById.clear();
+			this.allItems = [];
+			for (const p of plugins) {
+				this.pluginsById.set(p.id, p);
+				const statusBadge = p.enabled ? tuiTheme.success("[ON]") : tuiTheme.dim("[OFF]");
+				const configHint = p.configStatus.total === 0 ? tuiTheme.dim("(no config)") : `(${p.configStatus.set}/${p.configStatus.total} configured)`;
+				this.allItems.push({
+					value: p.id,
+					label: `${p.name}  ${statusBadge}`,
+					description: `${p.category}  v${p.version}  ${configHint}`
+				});
+			}
+			this.selectList = new SelectList(this.allItems, 14, tuiTheme.selectList);
+			this.selectList.onCancel = () => this.options.onClose();
+			this.selectList.onSelect = (item) => {
+				this.handlePluginSelect(item.value);
+			};
+			const filter = this.filterInput.getValue();
+			if (filter) this.selectList.setFilter(filter);
+		} catch {} finally {
+			this.loading = false;
+			this.options.requestRender();
+		}
+	}
+	async handlePluginSelect(pluginId) {
+		const plugin = this.pluginsById.get(pluginId);
+		if (!plugin) return;
+		const newEnabled = !plugin.enabled;
+		await this.options.onTogglePlugin(pluginId, newEnabled);
+		this.statusMessage = `${plugin.name} ${newEnabled ? "enabled" : "disabled"}.`;
+		this.loadPlugins();
+	}
+	beginEditSelectedPlugin() {
+		const selected = this.selectList.getSelectedItem();
+		if (!selected) return;
+		const plugin = this.pluginsById.get(selected.value);
+		if (!plugin) return;
+		this.editingPluginId = plugin.id;
+		this.editingPluginName = plugin.name;
+		this.editingParamsByKey = Object.fromEntries(plugin.parameters.map((p) => [p.key, p]));
+		this.editingKeys = [...plugin.parameters].sort((a, b) => {
+			const reqA = a.required ? 0 : 1;
+			const reqB = b.required ? 0 : 1;
+			if (reqA !== reqB) return reqA - reqB;
+			return a.key.localeCompare(b.key);
+		}).map((p) => p.key);
+		this.editingDraft = Object.fromEntries(plugin.parameters.map((p) => [p.key, p.value]));
+		this.editingIndex = 0;
+		this.showUnmaskedValues = false;
+		this.state = "edit-select";
+		this.statusMessage = "";
+		this.options.requestRender();
+	}
+	async saveEditingConfig() {
+		const pluginId = this.editingPluginId;
+		if (!pluginId) return;
+		const missingRequired = this.editingKeys.filter((key) => {
+			if (!this.editingParamsByKey[key]?.required) return false;
+			return (this.editingDraft[key] ?? "").trim() === "";
+		});
+		if (missingRequired.length > 0) {
+			this.statusMessage = tuiTheme.error(`Missing required settings: ${missingRequired.join(", ")}`);
+			this.options.requestRender();
+			return;
+		}
+		try {
+			await this.options.onConfigSave(pluginId, this.editingDraft);
+			this.statusMessage = `Saved settings for ${this.editingPluginName}.`;
+			this.state = "list";
+			this.editingPluginId = null;
+			this.editingPluginName = "";
+			this.editingKeys = [];
+			this.editingParamsByKey = {};
+			this.editingDraft = {};
+			this.editingIndex = 0;
+			await this.loadPlugins();
+		} catch (err) {
+			this.statusMessage = tuiTheme.error(`Failed to save: ${err instanceof Error ? err.message : String(err)}`);
+			this.options.requestRender();
+		}
+	}
+	cancelEditing() {
+		this.state = "list";
+		this.editingPluginId = null;
+		this.editingPluginName = "";
+		this.editingKeys = [];
+		this.editingParamsByKey = {};
+		this.editingDraft = {};
+		this.editingIndex = 0;
+		this.statusMessage = "Edit cancelled.";
+		this.options.requestRender();
+	}
+	toggleValueMask() {
+		this.showUnmaskedValues = !this.showUnmaskedValues;
+		this.options.requestRender();
+	}
+	handleEditSelectInput(data) {
+		const kb = getEditorKeybindings();
+		if (kb.matches(data, "selectCancel")) {
+			this.cancelEditing();
+			return;
+		}
+		if (matchesKey(data, "ctrl+u")) {
+			this.toggleValueMask();
+			return;
+		}
+		if (data === "a" || data === "A") {
+			this.newKeyInput.setValue("");
+			this.state = "add-key";
+			this.options.requestRender();
+			return;
+		}
+		if (kb.matches(data, "selectUp")) {
+			this.editingIndex = Math.max(0, this.editingIndex - 1);
+			this.options.requestRender();
+			return;
+		}
+		if (kb.matches(data, "selectDown")) {
+			this.editingIndex = Math.min(this.editingKeys.length - 1, this.editingIndex + 1);
+			this.options.requestRender();
+			return;
+		}
+		if (data === "s" || data === "S") {
+			this.saveEditingConfig();
+			return;
+		}
+		if (kb.matches(data, "selectConfirm") && this.editingKeys.length > 0) {
+			const key = this.editingKeys[this.editingIndex];
+			const currentValue = this.editingDraft[key] ?? "";
+			this.valueInput.setValue(currentValue);
+			this.state = "edit-value";
+			this.options.requestRender();
+		}
+	}
+	handleAddKeyInput(data) {
+		const kb = getEditorKeybindings();
+		if (kb.matches(data, "selectCancel")) {
+			this.state = "edit-select";
+			this.options.requestRender();
+			return;
+		}
+		if (kb.matches(data, "selectConfirm")) {
+			const key = this.newKeyInput.getValue().trim();
+			if (!key) {
+				this.statusMessage = tuiTheme.error("Setting key cannot be empty.");
+				this.options.requestRender();
+				return;
+			}
+			if (key in this.editingDraft) {
+				this.statusMessage = tuiTheme.error(`Setting "${key}" already exists.`);
+				this.options.requestRender();
+				return;
+			}
+			this.editingKeys.push(key);
+			this.editingParamsByKey[key] = {
+				key,
+				label: key,
+				value: "",
+				required: false
+			};
+			this.editingDraft[key] = "";
+			this.editingIndex = this.editingKeys.length - 1;
+			this.valueInput.setValue("");
+			this.state = "edit-value";
+			this.statusMessage = "";
+			this.options.requestRender();
+			return;
+		}
+		this.newKeyInput.handleInput(data);
+		this.options.requestRender();
+	}
+	handleEditValueInput(data) {
+		const kb = getEditorKeybindings();
+		if (kb.matches(data, "selectCancel")) {
+			this.state = "edit-select";
+			this.options.requestRender();
+			return;
+		}
+		if (matchesKey(data, "ctrl+u")) {
+			this.toggleValueMask();
+			return;
+		}
+		if (kb.matches(data, "selectConfirm")) {
+			const key = this.editingKeys[this.editingIndex];
+			this.editingDraft[key] = this.valueInput.getValue();
+			this.state = "edit-select";
+			this.options.requestRender();
+			return;
+		}
+		this.valueInput.handleInput(data);
+		this.options.requestRender();
+	}
+	handleInput(data) {
+		const kb = getEditorKeybindings();
+		if (this.state === "edit-select") {
+			this.handleEditSelectInput(data);
+			return;
+		}
+		if (this.state === "add-key") {
+			this.handleAddKeyInput(data);
+			return;
+		}
+		if (this.state === "edit-value") {
+			this.handleEditValueInput(data);
+			return;
+		}
+		if (kb.matches(data, "selectUp") || kb.matches(data, "selectDown") || kb.matches(data, "selectConfirm") || kb.matches(data, "selectCancel")) {
+			this.selectList.handleInput(data);
+			return;
+		}
+		if (data === " ") {
+			const selected = this.selectList.getSelectedItem();
+			if (selected) this.handlePluginSelect(selected.value);
+			return;
+		}
+		if (data === "e" || data === "E") {
+			this.beginEditSelectedPlugin();
+			return;
+		}
+		const before = this.filterInput.getValue();
+		this.filterInput.handleInput(data);
+		const after = this.filterInput.getValue();
+		if (after !== before) this.selectList.setFilter(after);
+	}
+	render(width) {
+		this.filterInput.focused = this.focused && this.state === "list";
+		if (this.loading && this.state === "list") return [tuiTheme.dim("  Loading installed plugins…")];
+		if (this.state === "edit-select") return renderEditSelectView({
+			editingPluginName: this.editingPluginName,
+			editingKeys: this.editingKeys,
+			editingIndex: this.editingIndex,
+			editingDraft: this.editingDraft,
+			editingParamsByKey: this.editingParamsByKey,
+			showUnmaskedValues: this.showUnmaskedValues
+		});
+		if (this.state === "add-key") return renderAddKeyView({
+			width,
+			focused: this.focused,
+			editingPluginName: this.editingPluginName,
+			newKeyInput: this.newKeyInput
+		});
+		if (this.state === "edit-value") return renderEditValueView({
+			width,
+			focused: this.focused,
+			editingPluginName: this.editingPluginName,
+			editingKeys: this.editingKeys,
+			editingIndex: this.editingIndex,
+			showUnmaskedValues: this.showUnmaskedValues,
+			valueInput: this.valueInput
+		});
+		const lines = [...this.filterInput.render(width).map((l) => `  ${l}`), ""];
+		if (this.statusMessage) {
+			lines.push(`  ${this.statusMessage}`);
+			lines.push("");
+		}
+		if (this.allItems.length === 0) {
+			lines.push(tuiTheme.dim("  No plugins installed."));
+			lines.push(tuiTheme.dim("  Use the Store tab to browse and install plugins."));
+		} else lines.push(...this.selectList.render(width));
+		lines.push("");
+		lines.push(tuiTheme.dim("  ↑↓ navigate • Enter toggle • Space toggle • e edit settings • type to filter"));
+		return lines;
+	}
+	invalidate() {
+		this.filterInput.invalidate();
+		this.selectList.invalidate();
+		this.valueInput.invalidate();
+		this.newKeyInput.invalidate();
+	}
+};
+
+//#endregion
+export { InstalledPluginsTab };