miladyai 2.0.0-alpha.27

package/dist/services/sandbox-manager.js

@@ -0,0 +1,297 @@
+import { createEngine, detectBestEngine } from "./sandbox-engine.js";
+import os from "node:os";
+import { join } from "node:path";
+import { mkdirSync } from "node:fs";
+
+//#region src/services/sandbox-manager.ts
+/** Sandbox container lifecycle: create, exec, health check, teardown. */
+var SandboxManager = class {
+	constructor(config) {
+		this.state = "uninitialized";
+		this.containerId = null;
+		this.browserContainerId = null;
+		this.eventLog = [];
+		this.config = {
+			image: "milady-sandbox:bookworm-slim",
+			containerPrefix: "milady-sandbox",
+			workdir: "/workspace",
+			network: "none",
+			user: "1000:1000",
+			capDrop: ["ALL"],
+			memory: "512m",
+			cpus: 1,
+			pidsLimit: 256,
+			...config
+		};
+		this.engine = config.engineType ? createEngine(config.engineType) : detectBestEngine();
+	}
+	getState() {
+		return this.state;
+	}
+	getMode() {
+		return this.config.mode;
+	}
+	isReady() {
+		return this.state === "ready";
+	}
+	getMainContainerConfig() {
+		const image = this.config.image ?? "milady-sandbox:bookworm-slim";
+		const containerPrefix = this.config.containerPrefix ?? "milady-sandbox";
+		const workdir = this.config.workdir ?? "/workspace";
+		const network = this.config.network ?? "none";
+		const user = this.config.user ?? "1000:1000";
+		const wsRoot = this.config.workspaceRoot ?? join(process.env.HOME ?? process.env.USERPROFILE ?? os.tmpdir(), ".milady", "sandbox-workspace");
+		mkdirSync(wsRoot, { recursive: true });
+		return {
+			image,
+			containerPrefix,
+			workdir,
+			network,
+			user,
+			wsRoot
+		};
+	}
+	async createMainContainer() {
+		const config = this.getMainContainerConfig();
+		return this.engine.runContainer({
+			image: config.image,
+			name: `${config.containerPrefix}-${Date.now()}`,
+			detach: true,
+			mounts: [{
+				host: config.wsRoot,
+				container: config.workdir,
+				readonly: false
+			}],
+			env: this.config.env ?? {},
+			network: config.network,
+			user: config.user,
+			capDrop: this.config.capDrop ?? [],
+			memory: this.config.memory,
+			cpus: this.config.cpus,
+			pidsLimit: this.config.pidsLimit,
+			readOnlyRoot: this.config.readOnlyRoot,
+			dns: this.config.dns
+		});
+	}
+	async cleanupContainer(containerId) {
+		if (!containerId) return;
+		await this.engine.stopContainer(containerId);
+		await this.engine.removeContainer(containerId);
+	}
+	setState(newState) {
+		const oldState = this.state;
+		this.state = newState;
+		this.emitEvent({
+			timestamp: Date.now(),
+			type: "state_change",
+			detail: `${oldState} → ${newState}`
+		});
+	}
+	async start() {
+		if (this.config.mode === "off") {
+			this.setState("stopped");
+			return;
+		}
+		if (this.config.mode === "light") {
+			this.setState("ready");
+			return;
+		}
+		this.setState("initializing");
+		try {
+			const config = this.getMainContainerConfig();
+			if (!this.engine.isAvailable()) throw new Error(`Container engine "${this.engine.engineType}" is not available. Install Docker or Apple Container.`);
+			if (!this.engine.imageExists(config.image)) try {
+				await this.engine.pullImage(config.image);
+			} catch {
+				throw new Error(`Sandbox image "${config.image}" not found. Build with: scripts/sandbox-setup.sh`);
+			}
+			const orphans = this.engine.listContainers(config.containerPrefix);
+			for (const id of orphans) {
+				await this.engine.stopContainer(id);
+				await this.engine.removeContainer(id);
+			}
+			this.containerId = await this.createMainContainer();
+			this.emitEvent({
+				timestamp: Date.now(),
+				type: "container_start",
+				detail: `Container started: ${this.containerId}`
+			});
+			if (this.config.browser?.enabled && this.config.browser?.autoStart) try {
+				this.browserContainerId = await this.createBrowserContainer();
+			} catch (err) {
+				this.emitEvent({
+					timestamp: Date.now(),
+					type: "error",
+					detail: `Browser container start failed: ${err instanceof Error ? err.message : String(err)}`
+				});
+			}
+			if (await this.healthCheck()) this.setState("ready");
+			else this.setState("degraded");
+		} catch (err) {
+			this.emitEvent({
+				timestamp: Date.now(),
+				type: "error",
+				detail: `Sandbox start failed: ${err instanceof Error ? err.message : String(err)}`
+			});
+			this.setState("degraded");
+			throw err;
+		}
+	}
+	async recover() {
+		if (this.state !== "degraded") return;
+		this.setState("recovering");
+		this.emitEvent({
+			timestamp: Date.now(),
+			type: "state_change",
+			detail: "Attempting recovery from degraded state"
+		});
+		try {
+			const config = this.getMainContainerConfig();
+			await this.cleanupContainer(this.containerId);
+			await this.cleanupContainer(this.browserContainerId);
+			this.containerId = null;
+			this.browserContainerId = null;
+			const orphans = this.engine.listContainers(config.containerPrefix);
+			for (const id of orphans) {
+				await this.engine.stopContainer(id);
+				await this.engine.removeContainer(id);
+			}
+			this.containerId = await this.createMainContainer();
+			if (await this.healthCheck()) this.setState("ready");
+			else this.setState("degraded");
+		} catch (err) {
+			this.emitEvent({
+				timestamp: Date.now(),
+				type: "error",
+				detail: `Recovery failed: ${err instanceof Error ? err.message : String(err)}`
+			});
+			this.setState("degraded");
+		}
+	}
+	async stop() {
+		this.setState("stopping");
+		try {
+			await this.cleanupContainer(this.browserContainerId);
+			await this.cleanupContainer(this.containerId);
+			this.browserContainerId = null;
+			this.containerId = null;
+		} catch (err) {
+			this.emitEvent({
+				timestamp: Date.now(),
+				type: "error",
+				detail: `Sandbox stop error: ${err instanceof Error ? err.message : String(err)}`
+			});
+		}
+		this.setState("stopped");
+	}
+	async exec(options) {
+		const start = Date.now();
+		if (this.config.mode === "off" || this.config.mode === "light") return {
+			exitCode: 1,
+			stdout: "",
+			stderr: "Sandbox exec not available in current mode",
+			durationMs: Date.now() - start,
+			executedInSandbox: false
+		};
+		if (!this.containerId || this.state !== "ready") {
+			this.emitEvent({
+				timestamp: Date.now(),
+				type: "exec_denied",
+				detail: `Sandbox not ready (state=${this.state})`
+			});
+			return {
+				exitCode: 1,
+				stdout: "",
+				stderr: `Sandbox not ready (state=${this.state})`,
+				durationMs: Date.now() - start,
+				executedInSandbox: false
+			};
+		}
+		this.emitEvent({
+			timestamp: Date.now(),
+			type: "exec",
+			detail: options.command.substring(0, 200),
+			metadata: { workdir: options.workdir ?? this.config.workdir ?? "/workspace" }
+		});
+		try {
+			return {
+				...await this.engine.execInContainer({
+					containerId: this.containerId,
+					command: options.command,
+					workdir: options.workdir,
+					env: options.env,
+					timeoutMs: options.timeoutMs,
+					stdin: options.stdin
+				}),
+				executedInSandbox: true
+			};
+		} catch (err) {
+			return {
+				exitCode: 1,
+				stdout: "",
+				stderr: `Exec error: ${err instanceof Error ? err.message : String(err)}`,
+				durationMs: Date.now() - start,
+				executedInSandbox: false
+			};
+		}
+	}
+	getBrowserCdpEndpoint() {
+		if (!this.browserContainerId) return null;
+		return `http://localhost:${this.config.browser?.cdpPort ?? 9222}`;
+	}
+	getBrowserWsEndpoint() {
+		if (!this.browserContainerId) return null;
+		return `ws://localhost:${this.config.browser?.cdpPort ?? 9222}`;
+	}
+	async createBrowserContainer() {
+		const name = `${this.config.containerPrefix}-browser-${Date.now()}`;
+		const cdpPort = this.config.browser?.cdpPort ?? 9222;
+		const vncPort = this.config.browser?.vncPort ?? 5900;
+		const image = this.config.browser?.image ?? "milady-sandbox-browser:bookworm-slim";
+		return this.engine.runContainer({
+			image,
+			name,
+			detach: true,
+			mounts: [],
+			env: {},
+			network: "bridge",
+			user: "1000:1000",
+			capDrop: [],
+			ports: [{
+				host: cdpPort,
+				container: 9222
+			}, {
+				host: vncPort,
+				container: 5900
+			}]
+		});
+	}
+	async healthCheck() {
+		if (!this.containerId) return false;
+		const healthy = await this.engine.healthCheck(this.containerId);
+		this.emitEvent({
+			timestamp: Date.now(),
+			type: "health_check",
+			detail: healthy ? "healthy" : "unhealthy"
+		});
+		return healthy;
+	}
+	emitEvent(event) {
+		this.eventLog.push(event);
+		if (this.eventLog.length > 1e3) this.eventLog = this.eventLog.slice(-500);
+	}
+	getEventLog() {
+		return [...this.eventLog];
+	}
+	getStatus() {
+		return {
+			state: this.state,
+			mode: this.config.mode,
+			containerId: this.containerId,
+			browserContainerId: this.browserContainerId
+		};
+	}
+};
+
+//#endregion
+export { SandboxManager };

package/dist/services/self-updater.js

@@ -0,0 +1,175 @@
+import { CHANNEL_DIST_TAGS } from "./update-checker.js";
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import { execSync, spawn } from "node:child_process";
+
+//#region src/services/self-updater.ts
+/**
+* Detects the installation method and runs the appropriate upgrade command.
+* Falls back to npm if detection is ambiguous.
+*/
+const NPM_PACKAGE_NAME = "miladyai";
+function whichSync(binary) {
+	try {
+		return execSync(`which ${binary}`, {
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			],
+			timeout: 5e3
+		}).toString().trim();
+	} catch {
+		return null;
+	}
+}
+function isLocalDev() {
+	try {
+		const rootPkg = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../package.json");
+		return JSON.parse(fs.readFileSync(rootPkg, "utf-8")).devDependencies !== void 0;
+	} catch {
+		return false;
+	}
+}
+function detectInstallMethod() {
+	const miladyBin = whichSync("milady");
+	if (!miladyBin) return isLocalDev() ? "local-dev" : "unknown";
+	let resolved;
+	try {
+		resolved = fs.realpathSync(miladyBin);
+	} catch {
+		resolved = miladyBin;
+	}
+	if (resolved.includes("/Cellar/") || resolved.includes("/homebrew/")) return "homebrew";
+	if (resolved.includes("/snap/")) return "snap";
+	if (resolved.includes("/flatpak/") || resolved.includes("ai.milady.Milady")) return "flatpak";
+	if (resolved.startsWith("/usr/") && !resolved.includes("node_modules")) return "apt";
+	if (resolved.includes("/.bun/")) return "bun-global";
+	if (resolved.includes("node_modules")) return "npm-global";
+	return "unknown";
+}
+function buildUpdateCommand(method, channel) {
+	const spec = `${NPM_PACKAGE_NAME}@${CHANNEL_DIST_TAGS[channel]}`;
+	switch (method) {
+		case "npm-global": return {
+			command: "npm",
+			args: [
+				"install",
+				"-g",
+				spec
+			]
+		};
+		case "bun-global": return {
+			command: "bun",
+			args: [
+				"install",
+				"-g",
+				spec
+			]
+		};
+		case "homebrew": return {
+			command: "brew",
+			args: ["upgrade", "milady"]
+		};
+		case "snap": return {
+			command: "sudo",
+			args: [
+				"snap",
+				"refresh",
+				"milady",
+				`--channel=${channel === "nightly" ? "edge" : channel === "beta" ? "beta" : "stable"}`
+			]
+		};
+		case "apt": return {
+			command: "sh",
+			args: ["-c", "sudo apt-get update && sudo apt-get install --only-upgrade -y milady"]
+		};
+		case "flatpak": return {
+			command: "flatpak",
+			args: ["update", "ai.milady.Milady"]
+		};
+		case "local-dev": return null;
+		case "unknown": return {
+			command: "npm",
+			args: [
+				"install",
+				"-g",
+				spec
+			]
+		};
+	}
+}
+function runCommand(command, args) {
+	return new Promise((resolve) => {
+		const child = spawn(command, args, { stdio: [
+			"inherit",
+			"inherit",
+			"pipe"
+		] });
+		let stderr = "";
+		child.stderr?.on("data", (chunk) => {
+			stderr += chunk.toString();
+			process.stderr.write(chunk);
+		});
+		child.on("error", (err) => {
+			resolve({
+				exitCode: 1,
+				stderr: err.message
+			});
+		});
+		child.on("close", (code) => {
+			resolve({
+				exitCode: code ?? 1,
+				stderr
+			});
+		});
+	});
+}
+function readPostUpdateVersion() {
+	try {
+		return execSync("milady --version", {
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			],
+			timeout: 1e4
+		}).toString().trim().match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/)?.[1] ?? null;
+	} catch {
+		return null;
+	}
+}
+async function performUpdate(currentVersion, channel, method) {
+	method ??= detectInstallMethod();
+	const cmdInfo = buildUpdateCommand(method, channel);
+	if (!cmdInfo) return {
+		success: false,
+		method,
+		command: "",
+		previousVersion: currentVersion,
+		newVersion: null,
+		error: "Cannot auto-update a local development install. Use git pull instead."
+	};
+	const commandString = `${cmdInfo.command} ${cmdInfo.args.join(" ")}`;
+	const { exitCode, stderr } = await runCommand(cmdInfo.command, cmdInfo.args);
+	if (exitCode !== 0) return {
+		success: false,
+		method,
+		command: commandString,
+		previousVersion: currentVersion,
+		newVersion: null,
+		error: stderr || `Update command exited with code ${exitCode}.`
+	};
+	return {
+		success: true,
+		method,
+		command: commandString,
+		previousVersion: currentVersion,
+		newVersion: readPostUpdateVersion(),
+		error: null
+	};
+}
+
+//#endregion
+export { detectInstallMethod, performUpdate };

package/dist/services/skill-catalog-client.js

@@ -0,0 +1,119 @@
+import path from "node:path";
+import { logger } from "@elizaos/core";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs/promises";
+
+//#region src/services/skill-catalog-client.ts
+/**
+* Skill Catalog Client for Milady.
+*
+* Provides a cached skill catalog (memory → file) sourced from the
+* local skills/.cache/catalog.json. Supports search and browse.
+*
+* @module services/skill-catalog-client
+*/
+let memoryCache = null;
+const MEMORY_TTL_MS = 6e5;
+/**
+* Find the catalog.json file. Checks:
+*   1. MILADY_SKILLS_CATALOG env override
+*   2. skills/.cache/catalog.json relative to package root
+*   3. ~/.milady/skills/catalog.json
+*/
+function findCatalogPaths() {
+	const paths = [];
+	const envPath = process.env.MILADY_SKILLS_CATALOG?.trim();
+	if (envPath) return [envPath];
+	let dir = import.meta.dirname ?? path.dirname(fileURLToPath(import.meta.url));
+	for (let i = 0; i < 5; i++) {
+		paths.push(path.join(dir, "skills", ".cache", "catalog.json"));
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+	if (home) paths.push(path.join(home, ".milady", "skills", "catalog.json"));
+	return paths;
+}
+async function readCatalogFile() {
+	for (const catalogPath of findCatalogPaths()) try {
+		const raw = await fs.readFile(catalogPath, "utf-8");
+		const parsed = JSON.parse(raw);
+		if (Array.isArray(parsed.data) && parsed.data.length > 0) {
+			logger.debug(`[skill-catalog] Loaded ${parsed.data.length} skills from ${catalogPath}`);
+			return parsed.data;
+		}
+	} catch {}
+	return null;
+}
+/** Get all skills from the catalog. Resolution: memory → file. */
+async function getCatalogSkills() {
+	if (memoryCache && Date.now() - memoryCache.loadedAt < MEMORY_TTL_MS) return memoryCache.skills;
+	const skills = await readCatalogFile();
+	if (!skills) {
+		logger.warn("[skill-catalog] No catalog file found");
+		return [];
+	}
+	memoryCache = {
+		skills,
+		loadedAt: Date.now()
+	};
+	return skills;
+}
+/** Force-refresh from file. */
+async function refreshCatalog() {
+	memoryCache = null;
+	return getCatalogSkills();
+}
+/** Get a single skill by slug. */
+async function getCatalogSkill(slug) {
+	return (await getCatalogSkills()).find((s) => s.slug === slug) ?? null;
+}
+/** Search skills by query (local fuzzy match on name/summary/slug). */
+async function searchCatalogSkills(query, limit = 30) {
+	const skills = await getCatalogSkills();
+	const lq = query.toLowerCase();
+	const terms = lq.split(/\s+/).filter((t) => t.length > 1);
+	const scored = [];
+	for (const skill of skills) {
+		const slug = skill.slug.toLowerCase();
+		const name = (skill.displayName ?? "").toLowerCase();
+		const summary = (skill.summary ?? "").toLowerCase();
+		let score = 0;
+		if (slug === lq || name === lq) score += 100;
+		else if (slug.includes(lq)) score += 50;
+		else if (name.includes(lq)) score += 45;
+		if (summary.includes(lq)) score += 30;
+		for (const tag of Object.keys(skill.tags)) if (tag.toLowerCase().includes(lq)) score += 20;
+		for (const term of terms) {
+			if (slug.includes(term)) score += 15;
+			if (name.includes(term)) score += 12;
+			if (summary.includes(term)) score += 8;
+		}
+		if (score > 0) {
+			if (skill.stats.downloads > 50) score += 3;
+			if (skill.stats.downloads > 200) score += 3;
+			if (skill.stats.stars > 0) score += 2;
+			if (skill.stats.installsCurrent > 0) score += 2;
+			scored.push({
+				s: skill,
+				score
+			});
+		}
+	}
+	scored.sort((a, b) => b.score - a.score || b.s.stats.downloads - a.s.stats.downloads);
+	const max = scored[0]?.score || 1;
+	return scored.slice(0, limit).map(({ s, score }) => ({
+		slug: s.slug,
+		displayName: s.displayName,
+		summary: s.summary,
+		score: score / max,
+		latestVersion: s.latestVersion?.version ?? null,
+		downloads: s.stats.downloads,
+		stars: s.stats.stars,
+		installs: s.stats.installsAllTime
+	}));
+}
+
+//#endregion
+export { getCatalogSkill, getCatalogSkills, refreshCatalog, searchCatalogSkills };