miladyai 2.0.0-alpha.27

package/dist/services/registry-client-endpoints.js

@@ -0,0 +1,166 @@
+import { isBlockedPrivateOrLinkLocalIp, normalizeHostLike } from "../security/network-policy.js";
+import { logger } from "@elizaos/core";
+import { lookup } from "node:dns/promises";
+import net from "node:net";
+
+//#region src/services/registry-client-endpoints.ts
+const BLOCKED_REGISTRY_HOST_LITERALS = new Set([
+	"localhost",
+	"127.0.0.1",
+	"::1",
+	"0.0.0.0",
+	"169.254.169.254"
+]);
+function normaliseEndpointUrl(url) {
+	return url.replace(/\/+$/, "");
+}
+function isDefaultEndpoint(url, defaultUrl) {
+	return normaliseEndpointUrl(url) === normaliseEndpointUrl(defaultUrl);
+}
+function parseRegistryEndpointUrl(rawUrl) {
+	let parsed;
+	try {
+		parsed = new URL(rawUrl);
+	} catch {
+		throw new Error("Endpoint URL must be a valid absolute URL");
+	}
+	if (parsed.protocol !== "https:") throw new Error("Endpoint URL must use https://");
+	const hostname = normalizeHostLike(parsed.hostname);
+	if (!hostname) throw new Error("Endpoint URL hostname is required");
+	if (BLOCKED_REGISTRY_HOST_LITERALS.has(hostname) || hostname.endsWith(".localhost") || hostname.endsWith(".local")) throw new Error(`Endpoint host "${hostname}" is blocked`);
+	if (net.isIP(hostname) && isBlockedPrivateOrLinkLocalIp(hostname)) throw new Error(`Endpoint host "${hostname}" is blocked`);
+	return parsed;
+}
+async function resolveRegistryEndpointUrlRejection(rawUrl) {
+	let parsed;
+	try {
+		parsed = parseRegistryEndpointUrl(rawUrl);
+	} catch (error) {
+		return {
+			rejection: error instanceof Error ? error.message : String(error),
+			endpoint: null
+		};
+	}
+	const hostname = normalizeHostLike(parsed.hostname);
+	if (!hostname) return {
+		rejection: "Endpoint URL hostname is required",
+		endpoint: null
+	};
+	if (net.isIP(hostname)) return {
+		rejection: null,
+		endpoint: {
+			parsed,
+			hostname,
+			pinnedAddress: hostname
+		}
+	};
+	let addresses;
+	try {
+		const resolved = await lookup(hostname, { all: true });
+		addresses = Array.isArray(resolved) ? resolved : [resolved];
+	} catch {
+		return {
+			rejection: `Could not resolve endpoint host "${hostname}"`,
+			endpoint: null
+		};
+	}
+	if (addresses.length === 0) return {
+		rejection: `Could not resolve endpoint host "${hostname}"`,
+		endpoint: null
+	};
+	for (const entry of addresses) if (isBlockedPrivateOrLinkLocalIp(entry.address)) return {
+		rejection: `Endpoint host "${hostname}" resolves to blocked address ${entry.address}`,
+		endpoint: null
+	};
+	return {
+		rejection: null,
+		endpoint: {
+			parsed,
+			hostname,
+			pinnedAddress: addresses[0]?.address ?? null
+		}
+	};
+}
+async function fetchSingleEndpoint(url, label) {
+	const { rejection, endpoint } = await resolveRegistryEndpointUrlRejection(url);
+	if (rejection || !endpoint) {
+		logger.warn(`[registry-client] Endpoint "${label}" (${url}) blocked: ${rejection ?? "validation failed"}`);
+		return null;
+	}
+	try {
+		if (endpoint.pinnedAddress && !net.isIP(endpoint.hostname)) {
+			const refreshed = await lookup(endpoint.hostname, { all: true });
+			const refreshedAddresses = new Set((Array.isArray(refreshed) ? refreshed : [refreshed]).map((entry) => normalizeHostLike(entry.address)));
+			if (!refreshedAddresses.has(normalizeHostLike(endpoint.pinnedAddress))) {
+				logger.warn(`[registry-client] Endpoint "${label}" (${url}) blocked: host resolution changed before fetch`);
+				return null;
+			}
+			for (const address of refreshedAddresses) if (isBlockedPrivateOrLinkLocalIp(address)) {
+				logger.warn(`[registry-client] Endpoint "${label}" (${url}) blocked: host resolves to blocked address ${address}`);
+				return null;
+			}
+		}
+		const resp = await fetch(url, { redirect: "error" });
+		if (!resp.ok) {
+			logger.warn(`[registry-client] Endpoint "${label}" (${url}): ${resp.status} ${resp.statusText}`);
+			return null;
+		}
+		const data = await resp.json();
+		if (!data.registry || typeof data.registry !== "object") {
+			logger.warn(`[registry-client] Endpoint "${label}" (${url}): missing registry field`);
+			return null;
+		}
+		const plugins = /* @__PURE__ */ new Map();
+		for (const [name, raw] of Object.entries(data.registry)) {
+			const e = raw;
+			const git = e.git ?? {};
+			const npm = e.npm ?? {};
+			const supports = e.supports ?? {
+				v0: false,
+				v1: false,
+				v2: false
+			};
+			plugins.set(name, {
+				name,
+				gitRepo: git.repo ?? "unknown/unknown",
+				gitUrl: `https://github.com/${git.repo ?? "unknown/unknown"}.git`,
+				description: e.description ?? "",
+				homepage: e.homepage ?? null,
+				topics: e.topics ?? [],
+				stars: e.stargazers_count ?? 0,
+				language: e.language ?? "TypeScript",
+				npm: {
+					package: npm.repo ?? name,
+					v0Version: npm.v0 ?? null,
+					v1Version: npm.v1 ?? null,
+					v2Version: npm.v2 ?? null
+				},
+				git: {
+					v0Branch: git.v0?.branch ?? null,
+					v1Branch: git.v1?.branch ?? null,
+					v2Branch: git.v2?.branch ?? null
+				},
+				supports
+			});
+		}
+		return plugins;
+	} catch (err) {
+		logger.warn(`[registry-client] Endpoint "${label}" (${url}) failed: ${err instanceof Error ? err.message : String(err)}`);
+		return null;
+	}
+}
+async function mergeCustomEndpoints(plugins, endpoints) {
+	const enabledEndpoints = endpoints.filter((ep) => ep.enabled !== false);
+	if (enabledEndpoints.length === 0) return;
+	const results = await Promise.allSettled(enabledEndpoints.map((ep) => fetchSingleEndpoint(ep.url, ep.label)));
+	for (const result of results) if (result.status === "fulfilled" && result.value) for (const [name, info] of result.value) {
+		if (plugins.has(name)) {
+			logger.warn(`[registry-client] Ignoring custom endpoint override for ${name}`);
+			continue;
+		}
+		plugins.set(name, info);
+	}
+}
+
+//#endregion
+export { isDefaultEndpoint, mergeCustomEndpoints, normaliseEndpointUrl, parseRegistryEndpointUrl };

package/dist/services/registry-client-local.js

@@ -0,0 +1,271 @@
+import { mergeAppMeta, resolveAppOverride } from "./registry-client-app-meta.js";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs/promises";
+
+//#region src/services/registry-client-local.ts
+function uniquePaths(paths) {
+	const seen = /* @__PURE__ */ new Set();
+	const ordered = [];
+	for (const p of paths) {
+		const resolved = path.resolve(p);
+		if (!seen.has(resolved)) {
+			seen.add(resolved);
+			ordered.push(resolved);
+		}
+	}
+	return ordered;
+}
+function resolveWorkspaceRoots() {
+	const envRoot = process.env.MILADY_WORKSPACE_ROOT?.trim();
+	if (envRoot) return uniquePaths([envRoot]);
+	const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+	const packageRoot = path.resolve(moduleDir, "..", "..");
+	const cwd = process.cwd();
+	return uniquePaths([
+		packageRoot,
+		cwd,
+		path.resolve(cwd, ".."),
+		path.resolve(cwd, "..", "..")
+	].filter((candidate) => Boolean(candidate)));
+}
+function repoString(repo) {
+	if (!repo) return null;
+	if (typeof repo === "string") return repo;
+	if (typeof repo.url === "string" && repo.url.length > 0) return repo.url;
+	return null;
+}
+function normaliseGitHubRepo(repo) {
+	if (!repo) return null;
+	const cleaned = repo.replace(/^git\+/, "").replace(/\.git$/, "").replace(/^https?:\/\/github\.com\//, "").replace(/^git@github\.com:/, "").trim();
+	if (!cleaned.includes("/")) return null;
+	return cleaned;
+}
+async function readJsonFile(filePath) {
+	try {
+		const raw = await fs.readFile(filePath, "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+function toLocalAppMeta(app, fallbackDisplayName) {
+	if (!app) return void 0;
+	const launchType = app.launchType ?? "url";
+	return {
+		displayName: app.displayName ?? fallbackDisplayName,
+		category: app.category ?? "game",
+		launchType,
+		launchUrl: app.launchUrl ?? null,
+		icon: app.icon ?? null,
+		capabilities: app.capabilities ?? [],
+		minPlayers: app.minPlayers ?? null,
+		maxPlayers: app.maxPlayers ?? null,
+		viewer: app.viewer
+	};
+}
+function toDisplayNameFromDirName(dirName) {
+	return dirName.replace(/^app-/, "").split("-").filter((part) => part.length > 0).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function parseRepositoryMetadata(repository) {
+	const gitRepo = normaliseGitHubRepo(repoString(repository)) ?? "local/workspace";
+	return {
+		gitRepo,
+		gitUrl: `https://github.com/${gitRepo}.git`
+	};
+}
+function buildDiscoveredEntry(packageDir, dirName, packageJson, manifest) {
+	if (!packageJson?.name || packageJson.name.length === 0) return null;
+	const packageAppMeta = toLocalAppMeta(packageJson.elizaos?.app, toDisplayNameFromDirName(dirName));
+	const mergedMeta = mergeAppMeta(toLocalAppMeta(manifest?.app, toDisplayNameFromDirName(dirName)), packageAppMeta);
+	const overriddenMeta = resolveAppOverride(packageJson.name, mergedMeta);
+	const kind = packageJson.elizaos?.kind === "app" || manifest?.kind === "app" ? "app" : overriddenMeta ? "app" : void 0;
+	const repo = parseRepositoryMetadata(packageJson.repository ?? manifest?.repository);
+	const description = packageJson.description ?? manifest?.description ?? "";
+	const homepage = packageJson.homepage ?? manifest?.homepage ?? overriddenMeta?.launchUrl ?? null;
+	const version = packageJson.version ?? manifest?.version ?? null;
+	return {
+		name: packageJson.name,
+		gitRepo: repo.gitRepo,
+		gitUrl: repo.gitUrl,
+		description,
+		homepage,
+		topics: [],
+		stars: 0,
+		language: "TypeScript",
+		npm: {
+			package: packageJson.name,
+			v0Version: null,
+			v1Version: null,
+			v2Version: version
+		},
+		git: {
+			v0Branch: null,
+			v1Branch: null,
+			v2Branch: "main"
+		},
+		supports: {
+			v0: false,
+			v1: false,
+			v2: true
+		},
+		localPath: packageDir,
+		kind,
+		appMeta: overriddenMeta ?? void 0
+	};
+}
+async function discoverLocalWorkspaceApps() {
+	const discovered = /* @__PURE__ */ new Map();
+	for (const workspaceRoot of resolveWorkspaceRoots()) {
+		const pluginsDir = path.join(workspaceRoot, "plugins");
+		let entries;
+		try {
+			entries = await fs.readdir(pluginsDir, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory() && !entry.isSymbolicLink() || !entry.name.startsWith("app-")) continue;
+			const packageDir = path.join(pluginsDir, entry.name);
+			const packageJson = await readJsonFile(path.join(packageDir, "package.json"));
+			if (!packageJson) continue;
+			const manifest = await readJsonFile(path.join(packageDir, "elizaos.plugin.json"));
+			const info = buildDiscoveredEntry(packageDir, entry.name, packageJson, manifest);
+			if (info) discovered.set(info.name, info);
+		}
+	}
+	const stateDir = process.env.MILADY_STATE_DIR?.trim() || path.join(os.homedir(), ".milady");
+	const installedBase = path.join(stateDir, "plugins", "installed");
+	try {
+		const installedEntries = await fs.readdir(installedBase, { withFileTypes: true });
+		for (const entry of installedEntries) {
+			if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+			const installDir = path.join(installedBase, entry.name);
+			const nmDir = path.join(installDir, "node_modules");
+			const pkgDirs = [];
+			try {
+				const nmEntries = await fs.readdir(nmDir, { withFileTypes: true });
+				for (const nm of nmEntries) if (nm.name.startsWith("@")) {
+					const scopeDir = path.join(nmDir, nm.name);
+					try {
+						const scopeEntries = await fs.readdir(scopeDir, { withFileTypes: true });
+						for (const se of scopeEntries) pkgDirs.push(path.join(scopeDir, se.name));
+					} catch {}
+				} else if (nm.isDirectory() || nm.isSymbolicLink()) pkgDirs.push(path.join(nmDir, nm.name));
+			} catch {
+				continue;
+			}
+			for (const pkgDir of pkgDirs) {
+				const pkgJson = await readJsonFile(path.join(pkgDir, "package.json"));
+				if (!pkgJson?.name) continue;
+				if (pkgJson.elizaos?.kind !== "app") continue;
+				if (discovered.has(pkgJson.name)) continue;
+				const manifest = await readJsonFile(path.join(pkgDir, "elizaos.plugin.json"));
+				const info = buildDiscoveredEntry(pkgDir, pkgJson.name.replace(/^@[^/]+\//, "").replace(/^plugin-/, "app-"), pkgJson, manifest);
+				if (info) discovered.set(info.name, info);
+			}
+		}
+	} catch {}
+	return discovered;
+}
+async function discoverNodeModulePlugins() {
+	const discovered = /* @__PURE__ */ new Map();
+	for (const workspaceRoot of resolveWorkspaceRoots()) {
+		const elizaosDir = path.join(workspaceRoot, "node_modules", "@elizaos");
+		let entries;
+		try {
+			entries = await fs.readdir(elizaosDir, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (!entry.name.startsWith("plugin-")) continue;
+			if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+			const packageDir = path.join(elizaosDir, entry.name);
+			const packageJson = await readJsonFile(path.join(packageDir, "package.json"));
+			if (!packageJson?.name) continue;
+			if (!(packageJson.packageType === "plugin" || packageJson.keywords?.includes("elizaos") || packageJson.elizaos !== void 0 || packageJson.agentConfig !== void 0)) continue;
+			if (packageJson.elizaos?.kind === "app") continue;
+			const repo = parseRepositoryMetadata(packageJson.repository);
+			const version = packageJson.version ?? null;
+			let localPath = packageDir;
+			try {
+				const realPath = await fs.realpath(packageDir);
+				if (realPath !== packageDir) localPath = realPath;
+			} catch {}
+			discovered.set(packageJson.name, {
+				name: packageJson.name,
+				gitRepo: repo.gitRepo,
+				gitUrl: repo.gitUrl,
+				description: packageJson.description ?? "",
+				homepage: packageJson.homepage ?? null,
+				topics: [],
+				stars: 0,
+				language: "TypeScript",
+				npm: {
+					package: packageJson.name,
+					v0Version: null,
+					v1Version: null,
+					v2Version: version
+				},
+				git: {
+					v0Branch: null,
+					v1Branch: null,
+					v2Branch: "main"
+				},
+				supports: {
+					v0: false,
+					v1: false,
+					v2: true
+				},
+				localPath
+			});
+		}
+	}
+	return discovered;
+}
+async function applyNodeModulePlugins(plugins) {
+	const localPlugins = await discoverNodeModulePlugins();
+	if (localPlugins.size === 0) return;
+	for (const [name, localInfo] of localPlugins.entries()) {
+		const existing = plugins.get(name);
+		if (!existing) plugins.set(name, localInfo);
+		else if (!existing.localPath) plugins.set(name, {
+			...existing,
+			localPath: localInfo.localPath
+		});
+	}
+}
+async function applyLocalWorkspaceApps(plugins) {
+	const localApps = await discoverLocalWorkspaceApps();
+	if (localApps.size === 0) return;
+	for (const [name, localInfo] of localApps.entries()) {
+		const existing = plugins.get(name);
+		if (!existing) {
+			plugins.set(name, localInfo);
+			continue;
+		}
+		plugins.set(name, {
+			...existing,
+			localPath: localInfo.localPath,
+			kind: localInfo.kind ?? existing.kind,
+			appMeta: mergeAppMeta(existing.appMeta, localInfo.appMeta),
+			description: localInfo.description || existing.description,
+			homepage: localInfo.homepage ?? existing.homepage,
+			npm: {
+				...existing.npm,
+				package: existing.npm.package || localInfo.npm.package,
+				v2Version: existing.npm.v2Version ?? localInfo.npm.v2Version
+			},
+			git: {
+				v0Branch: existing.git.v0Branch ?? localInfo.git.v0Branch,
+				v1Branch: existing.git.v1Branch ?? localInfo.git.v1Branch,
+				v2Branch: existing.git.v2Branch ?? localInfo.git.v2Branch
+			}
+		});
+	}
+}
+
+//#endregion
+export { applyLocalWorkspaceApps, applyNodeModulePlugins };

package/dist/services/registry-client-network.js

@@ -0,0 +1,93 @@
+//#region src/services/registry-client-network.ts
+async function fetchFromNetwork(params) {
+	const { generatedRegistryUrl, indexRegistryUrl, applyLocalWorkspaceApps, applyNodeModulePlugins, sanitizeSandbox } = params;
+	try {
+		const resp = await fetch(generatedRegistryUrl, { redirect: "error" });
+		if (resp.ok) {
+			const data = await resp.json();
+			const plugins = /* @__PURE__ */ new Map();
+			for (const [name, e] of Object.entries(data.registry)) {
+				const info = {
+					name,
+					gitRepo: e.git.repo,
+					gitUrl: `https://github.com/${e.git.repo}.git`,
+					description: e.description || "",
+					homepage: e.homepage,
+					topics: e.topics || [],
+					stars: e.stargazers_count || 0,
+					language: e.language || "TypeScript",
+					npm: {
+						package: e.npm.repo,
+						v0Version: e.npm.v0,
+						v1Version: e.npm.v1,
+						v2Version: e.npm.v2
+					},
+					git: {
+						v0Branch: e.git.v0?.branch ?? null,
+						v1Branch: e.git.v1?.branch ?? null,
+						v2Branch: e.git.v2?.branch ?? null
+					},
+					supports: e.supports
+				};
+				if (e.kind === "app" || e.app) info.kind = "app";
+				if (e.app) info.appMeta = {
+					displayName: e.app.displayName,
+					category: e.app.category,
+					launchType: e.app.launchType,
+					launchUrl: e.app.launchUrl,
+					icon: e.app.icon,
+					capabilities: e.app.capabilities || [],
+					minPlayers: e.app.minPlayers ?? null,
+					maxPlayers: e.app.maxPlayers ?? null,
+					viewer: e.app.viewer ? {
+						...e.app.viewer,
+						sandbox: sanitizeSandbox(e.app.viewer.sandbox)
+					} : void 0
+				};
+				plugins.set(name, info);
+			}
+			await applyLocalWorkspaceApps(plugins);
+			await applyNodeModulePlugins(plugins);
+			return plugins;
+		}
+	} catch {}
+	const resp = await fetch(indexRegistryUrl, { redirect: "error" });
+	if (!resp.ok) throw new Error(`index.json: ${resp.status} ${resp.statusText}`);
+	const data = await resp.json();
+	const plugins = /* @__PURE__ */ new Map();
+	for (const [name, gitRef] of Object.entries(data)) {
+		const repo = gitRef.replace(/^github:/, "");
+		plugins.set(name, {
+			name,
+			gitRepo: repo,
+			gitUrl: `https://github.com/${repo}.git`,
+			description: "",
+			homepage: null,
+			topics: [],
+			stars: 0,
+			language: "TypeScript",
+			npm: {
+				package: name,
+				v0Version: null,
+				v1Version: null,
+				v2Version: null
+			},
+			git: {
+				v0Branch: null,
+				v1Branch: null,
+				v2Branch: "next"
+			},
+			supports: {
+				v0: false,
+				v1: false,
+				v2: false
+			}
+		});
+	}
+	await applyLocalWorkspaceApps(plugins);
+	await applyNodeModulePlugins(plugins);
+	return plugins;
+}
+
+//#endregion
+export { fetchFromNetwork };

package/dist/services/registry-client-queries.js

@@ -0,0 +1,70 @@
+//#region src/services/registry-client-queries.ts
+function normalizePluginLookupAlias(name) {
+	const trimmed = name.trim();
+	if (!trimmed) return trimmed;
+	const lower = trimmed.toLowerCase();
+	if (lower === "obsidan") return "obsidian";
+	if (lower === "plugin-obsidan") return "plugin-obsidian";
+	if (lower === "@elizaos/plugin-obsidan") return "@elizaos/plugin-obsidian";
+	return trimmed;
+}
+function getPluginInfoFromRegistry(registry, name) {
+	let p = registry.get(name);
+	if (p) return p;
+	if (!name.startsWith("@")) {
+		p = registry.get(`@elizaos/${name}`);
+		if (p) return p;
+		p = registry.get(`@elizaos/plugin-${name}`);
+		if (p) return p;
+	}
+	const bare = name.replace(/^@[^/]+\//, "");
+	for (const [key, value] of registry) if (key.endsWith(`/${bare}`)) return value;
+	return null;
+}
+function scoreEntries(entries, query, limit, extraNames, extraTerms) {
+	const lq = query.toLowerCase();
+	const terms = lq.split(/\s+/).filter((t) => t.length > 1);
+	const scored = [];
+	for (const p of entries) {
+		const ln = p.name.toLowerCase();
+		const ld = p.description.toLowerCase();
+		const aliases = extraNames?.(p) ?? [];
+		let s = 0;
+		if (ln === lq || ln === `@elizaos/${lq}` || aliases.some((a) => a === lq)) s += 100;
+		else if (ln.includes(lq) || aliases.some((a) => a.includes(lq))) s += 50;
+		if (ld.includes(lq)) s += 30;
+		for (const t of p.topics) if (t.toLowerCase().includes(lq)) s += 25;
+		for (const t of extraTerms?.(p) ?? []) if (t.toLowerCase().includes(lq)) s += 25;
+		for (const term of terms) {
+			if (ln.includes(term) || aliases.some((a) => a.includes(term))) s += 15;
+			if (ld.includes(term)) s += 10;
+			for (const t of p.topics) if (t.toLowerCase().includes(term)) s += 8;
+		}
+		if (s > 0) {
+			if (p.stars > 100) s += 3;
+			if (p.stars > 500) s += 3;
+			if (p.stars > 1e3) s += 4;
+			scored.push({
+				p,
+				s
+			});
+		}
+	}
+	scored.sort((a, b) => b.s - a.s || b.p.stars - a.p.stars);
+	return scored.slice(0, limit);
+}
+function toPluginListItem(p) {
+	return {
+		name: p.name,
+		description: p.description,
+		stars: p.stars,
+		repository: `https://github.com/${p.gitRepo}`,
+		topics: p.topics,
+		latestVersion: p.npm.v2Version || p.npm.v1Version || p.npm.v0Version,
+		supports: p.supports,
+		npm: p.npm
+	};
+}
+
+//#endregion
+export { getPluginInfoFromRegistry, normalizePluginLookupAlias, scoreEntries, toPluginListItem };