@prometheus-ai/agent 0.5.3 → 0.5.8

package/src/extensibility/plugins/manager.ts

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import {
 	getPluginsDir,
@@ -11,6 +12,8 @@ import {
 	logger,
 } from "@prometheus-ai/utils";
 import { type GitSource, parseGitUrl } from "./git-url";
+import { installLegacyPackageSpecifierShim, loadLegacyPackageModule } from "./legacy-package-compat";
+import { resolvePluginManifestEntries } from "./loader";
 import { extractPackageName, parsePluginSpec } from "./parser";
 import type {
 	DoctorCheck,
@@ -74,6 +77,34 @@ function gitInstallSpec(original: string, source: GitSource): string {
 	return `${source.repo}#${source.ref}`;
 }
 
+function findGitPackageName(source: GitSource, deps: Record<string, string>): string | undefined {
+	for (const [key, value] of Object.entries(deps)) {
+		if (typeof value !== "string") {
+			continue;
+		}
+		const installedSource = parseGitUrl(value);
+		if (installedSource && installedSource.host === source.host && installedSource.path === source.path) {
+			return key;
+		}
+	}
+	return undefined;
+}
+
+function hasDefaultExport(value: unknown): value is { default?: unknown } {
+	return typeof value === "object" && value !== null && "default" in value;
+}
+
+function hasExtensionFactoryExport(module: unknown): boolean {
+	return typeof module === "function" || (hasDefaultExport(module) && typeof module.default === "function");
+}
+
+interface PluginPackageSnapshot {
+	readonly actualName: string;
+	readonly packagePath: string;
+	readonly backupRoot: string;
+	readonly backupPath: string;
+}
+
 // =============================================================================
 // Plugin Manager
 // =============================================================================
@@ -173,6 +204,88 @@ export class PluginManager {
 		}
 	}
 
+	async #snapshotInstalledPackage(actualName: string | undefined): Promise<PluginPackageSnapshot | null> {
+		if (!actualName) {
+			return null;
+		}
+		const packagePath = path.join(getPluginsNodeModules(), actualName);
+		try {
+			await fs.promises.lstat(packagePath);
+		} catch (err) {
+			if (isEnoent(err)) {
+				return null;
+			}
+			throw err;
+		}
+
+		const backupRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), "prometheus-plugin-backup-"));
+		const backupPath = path.join(backupRoot, "package");
+		await fs.promises.cp(packagePath, backupPath, { recursive: true, verbatimSymlinks: true });
+		return { actualName, packagePath, backupRoot, backupPath };
+	}
+
+	async #cleanupSnapshot(snapshot: PluginPackageSnapshot | null): Promise<void> {
+		if (!snapshot) {
+			return;
+		}
+		try {
+			await fs.promises.rm(snapshot.backupRoot, { recursive: true, force: true });
+		} catch (err) {
+			logger.warn("Failed to remove plugin install backup", { plugin: snapshot.actualName, error: String(err) });
+		}
+	}
+
+	async #rollbackFailedInstall(
+		actualName: string,
+		packageJsonBefore: string,
+		snapshot: PluginPackageSnapshot | null,
+	): Promise<void> {
+		await Bun.write(getPluginsPackageJson(), packageJsonBefore);
+		const packagePath = path.join(getPluginsNodeModules(), actualName);
+		await fs.promises.rm(packagePath, { recursive: true, force: true });
+		if (!snapshot) {
+			return;
+		}
+		await fs.promises.mkdir(path.dirname(snapshot.packagePath), { recursive: true });
+		await fs.promises.cp(snapshot.backupPath, snapshot.packagePath, { recursive: true, verbatimSymlinks: true });
+	}
+
+	async #validateInstalledExtensions(plugin: InstalledPlugin): Promise<void> {
+		const declaredEntries = resolvePluginManifestEntries(plugin, "extensions");
+		if (declaredEntries.length === 0) {
+			return;
+		}
+
+		const errors: string[] = [];
+		const loadable: string[] = [];
+		for (const { entry, resolvedPath } of declaredEntries) {
+			if (resolvedPath === null) {
+				errors.push(`${entry}: declared extension entry not found on disk`);
+			} else {
+				loadable.push(resolvedPath);
+			}
+		}
+
+		if (loadable.length > 0) {
+			installLegacyPackageSpecifierShim();
+			for (const extensionPath of loadable) {
+				try {
+					const module = await loadLegacyPackageModule(extensionPath);
+					if (!hasExtensionFactoryExport(module)) {
+						errors.push(`${extensionPath}: extension does not export a valid factory function`);
+					}
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					errors.push(`${extensionPath}: ${message}`);
+				}
+			}
+		}
+
+		if (errors.length > 0) {
+			throw new Error(`Plugin ${plugin.name} extension validation failed:\n${errors.join("\n")}`);
+		}
+	}
+
 	// ==========================================================================
 	// Install / Uninstall
 	// ==========================================================================
@@ -217,113 +330,131 @@ export class PluginManager {
 			};
 		}
 		const pkgJsonPath = getPluginsPackageJson();
-		const depsBefore = gitSource ? await this.#readDeps(pkgJsonPath) : {};
+		const packageJsonBefore = await Bun.file(pkgJsonPath).text();
+		const depsBefore = await this.#readDeps(pkgJsonPath);
 		const packageInstallSpec = gitSource ? gitInstallSpec(spec.packageName, gitSource) : spec.packageName;
+		const existingActualName = gitSource
+			? findGitPackageName(gitSource, depsBefore)
+			: extractPackageName(spec.packageName);
+		const packageSnapshot = await this.#snapshotInstalledPackage(existingActualName);
 
-		// Run npm install
-		const proc = Bun.spawn(["bun", "install", packageInstallSpec], {
-			cwd: getPluginsDir(),
-			stdin: "ignore",
-			stdout: "pipe",
-			stderr: "pipe",
-			windowsHide: true,
-		});
+		try {
+			// Run npm install
+			const proc = Bun.spawn(["bun", "install", packageInstallSpec], {
+				cwd: getPluginsDir(),
+				stdin: "ignore",
+				stdout: "pipe",
+				stderr: "pipe",
+				windowsHide: true,
+			});
 
-		const exitCode = await proc.exited;
-		if (exitCode !== 0) {
-			const stderr = await new Response(proc.stderr).text();
-			throw new Error(`npm install failed: ${stderr}`);
-		}
-		// Resolve actual package name. npm specs encode the name (strip version);
-		// git specs do not, so diff plugins/package.json deps to find the new entry.
-		let actualName: string;
-		if (gitSource) {
-			const depsAfter = await this.#readDeps(pkgJsonPath);
-			let resolved: string | undefined;
-			for (const key of Object.keys(depsAfter)) {
-				if (!(key in depsBefore)) {
-					resolved = key;
-					break;
-				}
+			const exitCode = await proc.exited;
+			if (exitCode !== 0) {
+				const stderr = await new Response(proc.stderr).text();
+				throw new Error(`npm install failed: ${stderr}`);
 			}
-			// Fallback: a force-reinstall of an already-present git plugin will not
-			// add a new key, just rewrite the existing one to the new spec value.
-			// Match by the install value for force-reinstalls where no new key is
-			// added (non-GitHub shorthands are normalized before bun sees them).
-			if (!resolved) {
-				const needle = packageInstallSpec.replace(/^git\+/i, "");
-				for (const [key, value] of Object.entries(depsAfter)) {
-					if (typeof value === "string" && value.includes(needle)) {
+			// Resolve actual package name. npm specs encode the name (strip version);
+			// git specs do not, so diff plugins/package.json deps to find the new entry.
+			let actualName: string;
+			if (gitSource) {
+				const depsAfter = await this.#readDeps(pkgJsonPath);
+				let resolved: string | undefined;
+				for (const key of Object.keys(depsAfter)) {
+					if (!(key in depsBefore)) {
 						resolved = key;
 						break;
 					}
 				}
+				// Fallback: a force-reinstall of an already-present git plugin will not
+				// add a new key, just rewrite the existing one to the new spec value.
+				// Match by repository identity, not by ref, so failed upgrades from
+				// one ref to another still resolve to the original package name.
+				if (!resolved) {
+					resolved = findGitPackageName(gitSource, depsAfter);
+				}
+				if (!resolved) {
+					throw new Error(
+						`Installed ${spec.packageName} but could not determine package name from plugins/package.json`,
+					);
+				}
+				actualName = resolved;
+			} else {
+				actualName = extractPackageName(spec.packageName);
 			}
-			if (!resolved) {
-				throw new Error(
-					`Installed ${spec.packageName} but could not determine package name from plugins/package.json`,
-				);
-			}
-			actualName = resolved;
-		} else {
-			actualName = extractPackageName(spec.packageName);
-		}
-		const pkgPath = path.join(getPluginsNodeModules(), actualName, "package.json");
+			const pkgPath = path.join(getPluginsNodeModules(), actualName, "package.json");
 
-		let pkg: { name: string; version: string; prometheus?: PluginManifest; pi?: PluginManifest };
-		try {
-			pkg = await Bun.file(pkgPath).json();
-		} catch (err) {
-			if (isEnoent(err)) {
-				throw new Error(`Package installed but package.json not found at ${pkgPath}`);
+			let pkg: { name: string; version: string; prometheus?: PluginManifest; pi?: PluginManifest };
+			try {
+				pkg = await Bun.file(pkgPath).json();
+			} catch (err) {
+				if (isEnoent(err)) {
+					throw new Error(`Package installed but package.json not found at ${pkgPath}`);
+				}
+				throw err;
 			}
-			throw err;
-		}
-		const manifest: PluginManifest = pkg.prometheus || pkg.pi || { version: pkg.version };
-		manifest.version = pkg.version;
-
-		// Resolve enabled features
-		let enabledFeatures: string[] | null = null;
-		if (spec.features === "*") {
-			// All features
-			enabledFeatures = manifest.features ? Object.keys(manifest.features) : null;
-		} else if (Array.isArray(spec.features)) {
-			if (spec.features.length > 0) {
-				// Validate requested features exist
-				if (manifest.features) {
-					for (const feat of spec.features) {
-						if (!(feat in manifest.features)) {
-							throw new Error(
-								`Unknown feature "${feat}" in ${actualName}. Available: ${Object.keys(manifest.features).join(", ")}`,
-							);
+			const manifest: PluginManifest = pkg.prometheus || pkg.pi || { version: pkg.version };
+			manifest.version = pkg.version;
+
+			// Resolve enabled features
+			let enabledFeatures: string[] | null = null;
+			if (spec.features === "*") {
+				// All features
+				enabledFeatures = manifest.features ? Object.keys(manifest.features) : null;
+			} else if (Array.isArray(spec.features)) {
+				if (spec.features.length > 0) {
+					// Validate requested features exist
+					if (manifest.features) {
+						for (const feat of spec.features) {
+							if (!(feat in manifest.features)) {
+								throw new Error(
+									`Unknown feature "${feat}" in ${actualName}. Available: ${Object.keys(manifest.features).join(", ")}`,
+								);
+							}
 						}
 					}
+					enabledFeatures = spec.features;
+				} else {
+					// Empty array = no optional features
+					enabledFeatures = [];
 				}
-				enabledFeatures = spec.features;
-			} else {
-				// Empty array = no optional features
-				enabledFeatures = [];
 			}
-		}
-		// null = use defaults
+			// null = use defaults
 
-		// Update runtime config
-		const config = await this.#ensureConfigLoaded();
-		config.plugins[pkg.name] = {
-			version: pkg.version,
-			enabledFeatures,
-			enabled: true,
-		};
-		await this.#saveRuntimeConfig();
+			const installedPlugin: InstalledPlugin = {
+				name: pkg.name,
+				version: pkg.version,
+				path: path.join(getPluginsNodeModules(), actualName),
+				manifest,
+				enabledFeatures,
+				enabled: true,
+			};
 
-		return {
-			name: pkg.name,
-			version: pkg.version,
-			path: path.join(getPluginsNodeModules(), actualName),
-			manifest,
-			enabledFeatures,
-			enabled: true,
-		};
+			try {
+				await this.#validateInstalledExtensions(installedPlugin);
+			} catch (err) {
+				try {
+					await this.#rollbackFailedInstall(actualName, packageJsonBefore, packageSnapshot);
+				} catch (rollbackErr) {
+					const message = err instanceof Error ? err.message : String(err);
+					const rollbackMessage = rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr);
+					throw new Error(`${message}\nRollback failed: ${rollbackMessage}`);
+				}
+				throw err;
+			}
+
+			// Update runtime config
+			const config = await this.#ensureConfigLoaded();
+			config.plugins[pkg.name] = {
+				version: pkg.version,
+				enabledFeatures,
+				enabled: true,
+			};
+			await this.#saveRuntimeConfig();
+
+			return installedPlugin;
+		} finally {
+			await this.#cleanupSnapshot(packageSnapshot);
+		}
 	}
 
 	/**
@@ -380,7 +511,7 @@ export class PluginManager {
 				if (isEnoent(err)) continue;
 				throw err;
 			}
-			const manifest: PluginManifest = pluginPkg.prometheus || pluginPkg.pi || { version: pluginPkg.version };
+			const manifest: PluginManifest = pluginPkg.prometheus || { version: pluginPkg.version };
 			manifest.version = pluginPkg.version;
 
 			const runtimeState = config.plugins[name] || {
@@ -446,7 +577,7 @@ export class PluginManager {
 
 		await fs.promises.symlink(absolutePath, linkPath);
 
-		const manifest: PluginManifest = pkg.prometheus || pkg.pi || { version: pkg.version };
+		const manifest: PluginManifest = pkg.prometheus || { version: pkg.version };
 		manifest.version = pkg.version;
 
 		// Add to runtime config
@@ -646,15 +777,15 @@ export class PluginManager {
 				}
 				throw err;
 			}
-			const hasManifest = !!(pluginPkg.prometheus || pluginPkg.pi);
-			const manifest: PluginManifest | undefined = pluginPkg.prometheus || pluginPkg.pi;
+			const hasManifest = !!pluginPkg.prometheus;
+			const manifest: PluginManifest | undefined = pluginPkg.prometheus;
 
 			checks.push({
 				name: `plugin:${name}`,
 				status: hasManifest ? "ok" : "warning",
 				message: hasManifest
 					? `v${pluginPkg.version}${pluginPkg.description ? ` - ${pluginPkg.description}` : ""}`
-					: `v${pluginPkg.version} - No Prometheus plugin manifest`,
+					: `v${pluginPkg.version} - No prometheus/pi manifest (not a Prometheus plugin)`,
 			});
 
 			// Check tools path exists if specified

package/src/extensibility/plugins/marketplace-auto-update.ts

@@ -0,0 +1,49 @@
+import { getProjectDir, logger } from "@prometheus-ai/utils";
+
+type MarketplaceAutoUpdateMode = "off" | "notify" | "auto";
+
+interface MarketplaceAutoUpdateOptions {
+	autoUpdate: MarketplaceAutoUpdateMode;
+	resolveActiveProjectRegistryPath: (cwd: string) => Promise<string | null>;
+	clearPluginRootsCache: () => void;
+}
+
+export function scheduleMarketplaceAutoUpdate(options: MarketplaceAutoUpdateOptions): void {
+	if (options.autoUpdate === "off") {
+		return;
+	}
+
+	void runMarketplaceAutoUpdate(options);
+}
+
+async function runMarketplaceAutoUpdate(options: MarketplaceAutoUpdateOptions): Promise<void> {
+	try {
+		// Startup perf: marketplace manager pulls scraper/fetch/cache code; keep it out of the initial TUI graph.
+		const {
+			MarketplaceManager,
+			getInstalledPluginsRegistryPath,
+			getMarketplacesCacheDir,
+			getMarketplacesRegistryPath,
+			getPluginsCacheDir,
+		} = await import("./marketplace");
+		const mgr = new MarketplaceManager({
+			marketplacesRegistryPath: getMarketplacesRegistryPath(),
+			installedRegistryPath: getInstalledPluginsRegistryPath(),
+			projectInstalledRegistryPath: (await options.resolveActiveProjectRegistryPath(getProjectDir())) ?? undefined,
+			marketplacesCacheDir: getMarketplacesCacheDir(),
+			pluginsCacheDir: getPluginsCacheDir(),
+			clearPluginRootsCache: options.clearPluginRootsCache,
+		});
+		await mgr.refreshStaleMarketplaces();
+		const updates = await mgr.checkForUpdates();
+		if (updates.length === 0) return;
+		if (options.autoUpdate === "auto") {
+			await mgr.upgradeAllPlugins();
+			logger.debug(`Auto-upgraded ${updates.length} marketplace plugin(s)`);
+		} else {
+			logger.debug(`${updates.length} marketplace plugin update(s) available — /marketplace upgrade`);
+		}
+	} catch {
+		// Silently ignore — network failure, corrupt data, offline.
+	}
+}

package/src/extensibility/plugins/types.ts

@@ -1,5 +1,5 @@
 // =============================================================================
-// Plugin Manifest Types (from package.json prometheus field, with legacy pi fallback)
+// Plugin Manifest Types (from package.json prometheus/pi field)
 // =============================================================================
 
 /**
@@ -22,7 +22,7 @@ export interface PluginFeature {
 }
 
 /**
- * Plugin manifest from package.json prometheus field. The legacy pi field is still accepted by the loader.
+ * Plugin manifest from package.json prometheus or pi field.
  */
 export interface PluginManifest {
 	/** Plugin display name (defaults to package name) */
@@ -106,7 +106,7 @@ export interface InstalledPlugin {
 	version: string;
 	/** Absolute path to package directory */
 	path: string;
-	/** Parsed Prometheus plugin manifest */
+	/** Parsed prometheus/pi manifest */
 	manifest: PluginManifest;
 	/**
 	 * Enabled features:

package/src/extensibility/shared-events.ts

@@ -17,7 +17,7 @@ import type { CompactionPreparation, CompactionResult } from "@prometheus-ai/age
 import type { ImageContent, TextContent, ToolResultMessage } from "@prometheus-ai/ai";
 import type { Rule } from "../capability/rule";
 import type { Goal, GoalModeState } from "../goals/state";
-import type { BranchSummaryEntry, CompactionEntry, SessionEntry } from "../session/session-manager";
+import type { BranchSummaryEntry, CompactionEntry, SessionEntry } from "../session/session-entries";
 import type { TodoItem } from "../tools/todo";
 
 // ============================================================================
@@ -204,13 +204,13 @@ export interface TurnEndEvent {
 export interface AutoCompactionStartEvent {
 	type: "auto_compaction_start";
 	reason: "threshold" | "overflow" | "idle" | "incomplete";
-	action: "context-full" | "handoff" | "shake";
+	action: "context-full" | "handoff" | "shake" | "snapcompact";
 }
 
 /** Fired when auto-compaction ends */
 export interface AutoCompactionEndEvent {
 	type: "auto_compaction_end";
-	action: "context-full" | "handoff" | "shake";
+	action: "context-full" | "handoff" | "shake" | "snapcompact";
 	result: CompactionResult | undefined;
 	aborted: boolean;
 	willRetry: boolean;