miladyai 2.0.0-alpha.27

package/dist/services/registry-client.js

@@ -0,0 +1,157 @@
+import { loadMiladyConfig, saveMiladyConfig } from "../config/config.js";
+import { sanitizeSandbox } from "./registry-client-app-meta.js";
+import { isDefaultEndpoint as isDefaultEndpoint$1, mergeCustomEndpoints, normaliseEndpointUrl, parseRegistryEndpointUrl } from "./registry-client-endpoints.js";
+import { applyLocalWorkspaceApps, applyNodeModulePlugins } from "./registry-client-local.js";
+import { fetchFromNetwork as fetchFromNetwork$1 } from "./registry-client-network.js";
+import { getPluginInfoFromRegistry, normalizePluginLookupAlias, scoreEntries, toPluginListItem } from "./registry-client-queries.js";
+import os from "node:os";
+import path from "node:path";
+import { logger } from "@elizaos/core";
+import fs from "node:fs/promises";
+
+//#region src/services/registry-client.ts
+/**
+* Registry Client for Milady.
+*
+* Provides a 3-tier cached registry (memory → file → network) that works
+* offline, in .app bundles, and in dev. Fetches from the next branch.
+*
+* @module services/registry-client
+*/
+const GENERATED_REGISTRY_URL = "https://raw.githubusercontent.com/elizaos-plugins/registry/next/generated-registry.json";
+const INDEX_REGISTRY_URL = "https://raw.githubusercontent.com/elizaos-plugins/registry/next/index.json";
+const CACHE_TTL_MS = 36e5;
+let memoryCache = null;
+async function fetchFromNetwork() {
+	try {
+		return await fetchFromNetwork$1({
+			generatedRegistryUrl: GENERATED_REGISTRY_URL,
+			indexRegistryUrl: INDEX_REGISTRY_URL,
+			applyLocalWorkspaceApps,
+			applyNodeModulePlugins,
+			sanitizeSandbox
+		});
+	} catch (err) {
+		logger.warn(`[registry-client] generated-registry/index fallback failed: ${err instanceof Error ? err.message : String(err)}`);
+		throw err;
+	}
+}
+function cacheFilePath() {
+	const base = process.env.MILADY_STATE_DIR?.trim() || path.join(os.homedir(), ".milady");
+	return path.join(base, "cache", "registry.json");
+}
+async function readFileCache() {
+	try {
+		const raw = await fs.readFile(cacheFilePath(), "utf-8");
+		const parsed = JSON.parse(raw);
+		if (typeof parsed.fetchedAt !== "number" || !Array.isArray(parsed.plugins)) return null;
+		if (Date.now() - parsed.fetchedAt > CACHE_TTL_MS) return null;
+		return new Map(parsed.plugins);
+	} catch {
+		return null;
+	}
+}
+async function writeFileCache(plugins) {
+	const filePath = cacheFilePath();
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
+	await fs.writeFile(filePath, JSON.stringify({
+		fetchedAt: Date.now(),
+		plugins: [...plugins.entries()]
+	}), "utf-8");
+}
+/** Return the list of custom registry endpoints from config. */
+function getConfiguredEndpoints() {
+	try {
+		return loadMiladyConfig().plugins?.registryEndpoints ?? [];
+	} catch {
+		return [];
+	}
+}
+/** Add a custom registry endpoint. Blocks duplicate URLs. */
+function addRegistryEndpoint(label, url) {
+	const normalised = normaliseEndpointUrl(parseRegistryEndpointUrl(url).toString());
+	if (isDefaultEndpoint(normalised)) throw new Error("Cannot add the default registry as a custom endpoint.");
+	const cfg = loadMiladyConfig();
+	const endpoints = cfg.plugins?.registryEndpoints ?? [];
+	if (endpoints.some((ep) => normaliseEndpointUrl(ep.url) === normalised)) throw new Error(`Endpoint already exists: ${url}`);
+	if (!cfg.plugins) cfg.plugins = {};
+	cfg.plugins.registryEndpoints = [...endpoints, {
+		label,
+		url: normalised,
+		enabled: true
+	}];
+	saveMiladyConfig(cfg);
+	memoryCache = null;
+}
+/** Remove a custom registry endpoint by URL. Cannot remove the default. */
+function removeRegistryEndpoint(url) {
+	const normalised = normaliseEndpointUrl(url);
+	if (isDefaultEndpoint(normalised)) throw new Error("Cannot remove the default ElizaOS registry.");
+	const cfg = loadMiladyConfig();
+	const endpoints = cfg.plugins?.registryEndpoints ?? [];
+	const updated = endpoints.filter((ep) => normaliseEndpointUrl(ep.url) !== normalised);
+	if (updated.length === endpoints.length) throw new Error(`Endpoint not found: ${url}`);
+	if (!cfg.plugins) cfg.plugins = {};
+	cfg.plugins.registryEndpoints = updated;
+	saveMiladyConfig(cfg);
+	memoryCache = null;
+}
+/** Toggle an endpoint's enabled status. */
+function toggleRegistryEndpoint(url, enabled) {
+	const normalised = normaliseEndpointUrl(url);
+	const cfg = loadMiladyConfig();
+	const endpoints = cfg.plugins?.registryEndpoints ?? [];
+	const ep = endpoints.find((e) => normaliseEndpointUrl(e.url) === normalised);
+	if (!ep) throw new Error(`Endpoint not found: ${url}`);
+	ep.enabled = enabled;
+	if (!cfg.plugins) cfg.plugins = {};
+	cfg.plugins.registryEndpoints = endpoints;
+	saveMiladyConfig(cfg);
+	memoryCache = null;
+}
+function isDefaultEndpoint(url) {
+	return isDefaultEndpoint$1(url, GENERATED_REGISTRY_URL);
+}
+/** Get all plugins. Resolution: memory → file → network. */
+async function getRegistryPlugins() {
+	if (memoryCache && Date.now() - memoryCache.fetchedAt < CACHE_TTL_MS) return memoryCache.plugins;
+	const fromFile = await readFileCache();
+	if (fromFile) {
+		await applyLocalWorkspaceApps(fromFile);
+		await applyNodeModulePlugins(fromFile);
+		await mergeCustomEndpoints(fromFile, getConfiguredEndpoints());
+		memoryCache = {
+			plugins: fromFile,
+			fetchedAt: Date.now()
+		};
+		return fromFile;
+	}
+	logger.info("[registry-client] Fetching plugin registry from next branch...");
+	const plugins = await fetchFromNetwork();
+	await mergeCustomEndpoints(plugins, getConfiguredEndpoints());
+	logger.info(`[registry-client] Loaded ${plugins.size} plugins`);
+	memoryCache = {
+		plugins,
+		fetchedAt: Date.now()
+	};
+	writeFileCache(plugins).catch((err) => logger.warn(`[registry-client] Cache write failed: ${err instanceof Error ? err.message : String(err)}`));
+	return plugins;
+}
+/** Look up a plugin by name (exact → @elizaos/ prefix → bare suffix). */
+async function getPluginInfo(name) {
+	const registry = await getRegistryPlugins();
+	const normalizedName = normalizePluginLookupAlias(name);
+	const candidates = Array.from(new Set([normalizedName, name]));
+	for (const candidate of candidates) {
+		const info = getPluginInfoFromRegistry(registry, candidate);
+		if (info) return info;
+	}
+	return null;
+}
+/** Search non-app plugins by query. */
+async function searchNonAppPlugins(query, limit = 15) {
+	return scoreEntries([...(await getRegistryPlugins()).values()].filter((p) => p.kind !== "app"), query, limit).map(({ p }) => toPluginListItem(p));
+}
+
+//#endregion
+export { addRegistryEndpoint, getConfiguredEndpoints, getPluginInfo, getRegistryPlugins, isDefaultEndpoint, removeRegistryEndpoint, searchNonAppPlugins, toggleRegistryEndpoint };

package/dist/services/sandbox-engine.js

@@ -0,0 +1,511 @@
+import { arch, platform } from "node:os";
+import { execFileSync, spawn } from "node:child_process";
+
+//#region src/services/sandbox-engine.ts
+/** Cross-platform sandbox engine: Docker, Apple Container, auto-detect. */
+function appendMountArgs(args, mounts) {
+	for (const mount of mounts) if (mount.readonly) args.push("--mount", `type=bind,source=${mount.host},target=${mount.container},readonly`);
+	else args.push("-v", `${mount.host}:${mount.container}`);
+}
+function appendEnvArgs(args, env) {
+	for (const [key, value] of Object.entries(env)) args.push("-e", `${key}=${value}`);
+}
+function listContainersFromBinary(binary, prefix) {
+	try {
+		return execFileSync(binary, [
+			"ps",
+			"-a",
+			"--filter",
+			`name=${prefix}`,
+			"--format",
+			"{{.ID}}"
+		], {
+			encoding: "utf-8",
+			timeout: 1e4,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).split("\n").map((s) => s.trim()).filter(Boolean);
+	} catch {
+		return [];
+	}
+}
+function checkHealthWithBinary(binary, id) {
+	try {
+		const result = execFileSync(binary, [
+			"exec",
+			id,
+			"echo",
+			"healthy"
+		], {
+			encoding: "utf-8",
+			timeout: 5e3,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+		return Promise.resolve(result === "healthy");
+	} catch {
+		return Promise.resolve(false);
+	}
+}
+function getChildProcessErrorText(error) {
+	const execError = error;
+	return [
+		execError.message,
+		execError.stderr,
+		execError.stdout
+	].map((value) => {
+		if (value === void 0 || value === null) return "";
+		if (typeof value === "string") return value;
+		if (typeof value === "object" && "toString" in value) return value.toString();
+		return "";
+	}).filter(Boolean).join(" ").toLowerCase();
+}
+function isContainerVersionUnsupported(error) {
+	const errorText = getChildProcessErrorText(error);
+	return errorText.includes("unknown option") || errorText.includes("unrecognized option") || errorText.includes("invalid option") || errorText.includes("unknown flag") || errorText.includes("no such option");
+}
+async function runExecInContainer(opts) {
+	const { binary, args, timeoutMs, stdin } = opts;
+	const start = Date.now();
+	return new Promise((resolve) => {
+		const proc = spawn(binary, args, { stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		] });
+		let stdout = "";
+		let stderr = "";
+		const timeout = setTimeout(() => proc.kill("SIGKILL"), timeoutMs ?? 3e4);
+		proc.stdout.on("data", (data) => {
+			stdout += data.toString();
+		});
+		proc.stderr.on("data", (data) => {
+			stderr += data.toString();
+		});
+		if (stdin) {
+			proc.stdin.write(stdin);
+			proc.stdin.end();
+		}
+		proc.on("close", (code) => {
+			clearTimeout(timeout);
+			resolve({
+				exitCode: code ?? 1,
+				stdout,
+				stderr,
+				durationMs: Date.now() - start
+			});
+		});
+		proc.on("error", (err) => {
+			clearTimeout(timeout);
+			resolve({
+				exitCode: 1,
+				stdout,
+				stderr: `Exec error: ${err.message}`,
+				durationMs: Date.now() - start
+			});
+		});
+	});
+}
+function parseContainerCommand(command) {
+	const args = [];
+	let current = "";
+	let inSingleQuote = false;
+	let inDoubleQuote = false;
+	let escaping = false;
+	let tokenStarted = false;
+	const emitCurrent = () => {
+		if (tokenStarted) {
+			args.push(current);
+			current = "";
+			tokenStarted = false;
+		}
+	};
+	const trimmed = command.trim();
+	if (trimmed.length === 0) throw new Error("Container exec command is required");
+	for (let i = 0; i < trimmed.length; i++) {
+		const char = trimmed[i];
+		if (escaping) {
+			current += char;
+			escaping = false;
+			continue;
+		}
+		if (inSingleQuote) {
+			if (char === "'") inSingleQuote = false;
+			else {
+				current += char;
+				tokenStarted = true;
+			}
+			continue;
+		}
+		if (inDoubleQuote) {
+			if (char === "\"") inDoubleQuote = false;
+			else if (char === "\\") {
+				const next = trimmed[i + 1];
+				if (next === "\\" || next === "\"" || next === "$" || next === "`") {
+					i += 1;
+					current += trimmed[i];
+				} else current += char;
+			} else current += char;
+			tokenStarted = true;
+			continue;
+		}
+		if (char === "'") {
+			inSingleQuote = true;
+			tokenStarted = true;
+			continue;
+		}
+		if (char === "\"") {
+			inDoubleQuote = true;
+			tokenStarted = true;
+			continue;
+		}
+		if (char === "\\") {
+			if (i + 1 >= trimmed.length) throw new Error("Container exec command cannot end with dangling escape");
+			escaping = true;
+			continue;
+		}
+		if (/\s/.test(char)) {
+			emitCurrent();
+			continue;
+		}
+		if (char === "&" || char === "|" || char === ";" || char === "<" || char === ">" || char === "$" || char === "`" || char === "(" || char === ")" || char === "{" || char === "}" || char === "\n" || char === "\r") throw new Error("Container exec command contains unsupported shell syntax");
+		current += char;
+		tokenStarted = true;
+	}
+	if (inSingleQuote || inDoubleQuote) throw new Error("Container exec command has unterminated quotes");
+	if (escaping) throw new Error("Container exec command has trailing escape");
+	emitCurrent();
+	if (args.length === 0) throw new Error("Container exec command is required");
+	return args;
+}
+var DockerEngine = class {
+	constructor() {
+		this.engineType = "docker";
+	}
+	isAvailable() {
+		try {
+			execFileSync("docker", ["info"], {
+				stdio: "ignore",
+				timeout: 1e4
+			});
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	getInfo() {
+		let version = "unknown";
+		try {
+			version = execFileSync("docker", ["--version"], {
+				encoding: "utf-8",
+				timeout: 5e3
+			}).trim();
+		} catch {}
+		return {
+			type: "docker",
+			available: this.isAvailable(),
+			version,
+			platform: platform(),
+			arch: arch(),
+			details: this.getDockerContext()
+		};
+	}
+	async runContainer(opts) {
+		const args = ["run"];
+		if (opts.detach) args.push("-d");
+		args.push("--name", opts.name);
+		if (opts.network) args.push("--network", opts.network);
+		if (opts.user) args.push("--user", opts.user);
+		if (opts.memory) args.push("--memory", opts.memory);
+		if (opts.cpus) args.push("--cpus", String(opts.cpus));
+		if (opts.pidsLimit) args.push("--pids-limit", String(opts.pidsLimit));
+		if (opts.readOnlyRoot) args.push("--read-only");
+		for (const cap of opts.capDrop) args.push("--cap-drop", cap);
+		appendMountArgs(args, opts.mounts);
+		appendEnvArgs(args, opts.env);
+		if (opts.ports) for (const p of opts.ports) args.push("-p", `${p.host}:${p.container}`);
+		if (opts.dns) for (const d of opts.dns) args.push("--dns", d);
+		args.push(opts.image);
+		return execFileSync("docker", args, {
+			encoding: "utf-8",
+			timeout: 6e4
+		}).trim().substring(0, 12);
+	}
+	async execInContainer(opts) {
+		const args = ["exec"];
+		if (opts.workdir) args.push("-w", opts.workdir);
+		if (opts.env) appendEnvArgs(args, opts.env);
+		const commandArgs = parseContainerCommand(opts.command);
+		args.push(opts.containerId, ...commandArgs);
+		return runExecInContainer({
+			binary: "docker",
+			args,
+			timeoutMs: opts.timeoutMs,
+			stdin: opts.stdin
+		});
+	}
+	async stopContainer(id) {
+		try {
+			execFileSync("docker", ["stop", id], {
+				timeout: 15e3,
+				stdio: "ignore"
+			});
+		} catch {}
+	}
+	async removeContainer(id) {
+		try {
+			execFileSync("docker", [
+				"rm",
+				"-f",
+				id
+			], {
+				timeout: 1e4,
+				stdio: "ignore"
+			});
+		} catch {}
+	}
+	isContainerRunning(id) {
+		try {
+			return execFileSync("docker", [
+				"inspect",
+				"-f",
+				"{{.State.Running}}",
+				id
+			], {
+				encoding: "utf-8",
+				timeout: 5e3,
+				stdio: [
+					"ignore",
+					"pipe",
+					"ignore"
+				]
+			}).trim() === "true";
+		} catch {
+			return false;
+		}
+	}
+	imageExists(image) {
+		try {
+			execFileSync("docker", [
+				"image",
+				"inspect",
+				image
+			], {
+				stdio: "ignore",
+				timeout: 1e4
+			});
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async pullImage(image) {
+		execFileSync("docker", ["pull", image], {
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			timeout: 3e5
+		});
+	}
+	listContainers(prefix) {
+		return listContainersFromBinary("docker", prefix);
+	}
+	async healthCheck(id) {
+		return checkHealthWithBinary("docker", id);
+	}
+	getDockerContext() {
+		try {
+			return execFileSync("docker", ["context", "show"], {
+				encoding: "utf-8",
+				timeout: 5e3,
+				stdio: [
+					"ignore",
+					"pipe",
+					"ignore"
+				]
+			}).trim();
+		} catch {
+			return "default";
+		}
+	}
+};
+var AppleContainerEngine = class {
+	constructor() {
+		this.engineType = "apple-container";
+	}
+	isAvailable() {
+		try {
+			execFileSync("container", ["--version"], {
+				stdio: "ignore",
+				timeout: 5e3
+			});
+			return true;
+		} catch (error) {
+			if (!isContainerVersionUnsupported(error)) return false;
+			try {
+				execFileSync("container", ["help"], {
+					stdio: "ignore",
+					timeout: 5e3
+				});
+				return true;
+			} catch {
+				return false;
+			}
+		}
+	}
+	getInfo() {
+		let version = "unknown";
+		try {
+			version = execFileSync("container", ["--version"], {
+				encoding: "utf-8",
+				timeout: 5e3
+			}).trim();
+		} catch {}
+		return {
+			type: "apple-container",
+			available: this.isAvailable(),
+			version,
+			platform: "darwin",
+			arch: arch(),
+			details: `Apple Silicon: ${arch() === "arm64" ? "yes" : "no"}`
+		};
+	}
+	async runContainer(opts) {
+		const args = [
+			"run",
+			"--name",
+			opts.name
+		];
+		appendMountArgs(args, opts.mounts);
+		appendEnvArgs(args, opts.env);
+		args.push(opts.image);
+		return new Promise((resolve, reject) => {
+			const proc = spawn("container", args, {
+				stdio: [
+					"pipe",
+					"pipe",
+					"pipe"
+				],
+				detached: true
+			});
+			let stderr = "";
+			proc.stderr.on("data", (chunk) => {
+				stderr += chunk.toString();
+			});
+			const checkTimer = setTimeout(() => {
+				if (proc.exitCode !== null) reject(/* @__PURE__ */ new Error(`Apple Container exited immediately: ${stderr}`));
+				else {
+					proc.unref();
+					resolve(opts.name);
+				}
+			}, 2e3);
+			proc.on("error", (err) => {
+				clearTimeout(checkTimer);
+				reject(/* @__PURE__ */ new Error(`Apple Container spawn failed: ${err.message}`));
+			});
+			proc.on("exit", (code) => {
+				if (code !== null && code !== 0) {
+					clearTimeout(checkTimer);
+					reject(/* @__PURE__ */ new Error(`Apple Container exited with code ${code}: ${stderr}`));
+				}
+			});
+		});
+	}
+	async execInContainer(opts) {
+		const args = ["exec"];
+		if (opts.workdir) args.push("-w", opts.workdir);
+		const commandArgs = parseContainerCommand(opts.command);
+		args.push(opts.containerId, ...commandArgs);
+		return runExecInContainer({
+			binary: "container",
+			args,
+			timeoutMs: opts.timeoutMs,
+			stdin: opts.stdin
+		});
+	}
+	async stopContainer(id) {
+		try {
+			execFileSync("container", ["stop", id], {
+				timeout: 15e3,
+				stdio: "ignore"
+			});
+		} catch {}
+	}
+	async removeContainer(id) {
+		try {
+			execFileSync("container", ["rm", id], {
+				timeout: 1e4,
+				stdio: "ignore"
+			});
+		} catch {}
+	}
+	isContainerRunning(id) {
+		try {
+			execFileSync("container", ["inspect", id], {
+				stdio: "ignore",
+				timeout: 5e3
+			});
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	imageExists(image) {
+		try {
+			execFileSync("container", [
+				"image",
+				"inspect",
+				image
+			], {
+				stdio: "ignore",
+				timeout: 1e4
+			});
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async pullImage(image) {
+		execFileSync("container", ["pull", image], {
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			timeout: 3e5
+		});
+	}
+	listContainers(prefix) {
+		return listContainersFromBinary("container", prefix);
+	}
+	async healthCheck(id) {
+		return checkHealthWithBinary("container", id);
+	}
+};
+/** Auto-detect: prefer Apple Container on ARM Mac, else Docker. */
+function detectBestEngine() {
+	if (platform() === "darwin" && arch() === "arm64") {
+		const apple = new AppleContainerEngine();
+		if (apple.isAvailable()) return apple;
+	}
+	return new DockerEngine();
+}
+function createEngine(type) {
+	switch (type) {
+		case "apple-container": return new AppleContainerEngine();
+		case "docker": return new DockerEngine();
+		case "auto": return detectBestEngine();
+		default: return new DockerEngine();
+	}
+}
+
+//#endregion
+export { createEngine, detectBestEngine };