@mastra/code-sdk 1.0.3-alpha.1 → 1.1.0-alpha.2

package/dist/plugins/manager.js

@@ -1,390 +1,384 @@
-import fs from "node:fs";
-import path from "node:path";
-import { execa } from "execa";
 import { getEntryPackageRoot, installPluginDependenciesForEntry } from "./dependencies.js";
-import { discoverLocalPlugins, installGithubPlugin, installLocalPlugin, NON_INTERACTIVE_GIT_ENV } from "./install.js";
-import { collectActivePluginTools, isInsideDirectory, loadPlugins, resolvePluginEntryPath } from "./loader.js";
-import { ensureMastraCodePackageLink } from "./package-link.js";
 import { getPluginScopePaths } from "./paths.js";
 import { loadPluginRegistry, removePluginRecord, savePluginRegistry, setPluginRecord } from "./registry.js";
+import { collectActivePluginTools, isInsideDirectory, loadPlugins, resolvePluginEntryPath } from "./loader.js";
+import { ensureMastraCodePackageLink } from "./package-link.js";
+import { NON_INTERACTIVE_GIT_ENV, discoverLocalPlugins, installGithubPlugin, installLocalPlugin } from "./install.js";
+import fs from "fs";
+import path from "path";
+import { execa } from "execa";
+//#region src/plugins/manager.ts
 const GITHUB_PLUGIN_POLL_INTERVAL_MS = 6e4;
 function gitExecOptions(cwd) {
-  return { cwd, env: NON_INTERACTIVE_GIT_ENV };
+	return {
+		cwd,
+		env: NON_INTERACTIVE_GIT_ENV
+	};
 }
 function getEntryVersion(entryPath) {
-  const stat = fs.statSync(entryPath, { bigint: true });
-  return `${stat.mtimeNs}:${stat.size}`;
-}
-class PluginManager {
-  constructor(options) {
-    this.options = options;
-  }
-  options;
-  loadedPlugins = [];
-  pluginTools = {};
-  rawPluginTools = {};
-  toolRenderConfigs = /* @__PURE__ */ new Map();
-  watchedLocalEntries = /* @__PURE__ */ new Set();
-  localEntryVersions = /* @__PURE__ */ new Map();
-  githubPollTimer;
-  githubPollInFlight;
-  reloadInFlight;
-  reloadListeners = /* @__PURE__ */ new Set();
-  githubUpdateListeners = /* @__PURE__ */ new Set();
-  onReload(listener) {
-    this.reloadListeners.add(listener);
-    return () => this.reloadListeners.delete(listener);
-  }
-  /** Notified with the display names of GitHub plugins that were updated by the background poll. */
-  onGithubPluginsUpdated(listener) {
-    this.githubUpdateListeners.add(listener);
-    return () => this.githubUpdateListeners.delete(listener);
-  }
-  async reload() {
-    if (this.reloadInFlight) return this.reloadInFlight;
-    this.reloadInFlight = (async () => {
-      this.loadedPlugins = await loadPlugins(this.options);
-      this.updateLocalEntryWatchers(this.loadedPlugins);
-      this.updateGithubPoller(this.loadedPlugins);
-      this.updatePluginRenderConfigs(this.loadedPlugins);
-      this.updatePluginTools(collectActivePluginTools(this.loadedPlugins));
-      await this.notifyReloadListeners(this.loadedPlugins);
-      return this.loadedPlugins;
-    })().finally(() => {
-      this.reloadInFlight = void 0;
-    });
-    return this.reloadInFlight;
-  }
-  async listPlugins() {
-    if (this.loadedPlugins.length === 0) {
-      await this.reload();
-    }
-    return this.loadedPlugins;
-  }
-  getLoadedPlugins() {
-    return this.loadedPlugins;
-  }
-  getPluginTools() {
-    return this.pluginTools;
-  }
-  getToolRenderConfig(toolName) {
-    return this.toolRenderConfigs.get(toolName);
-  }
-  getPluginSkillPaths() {
-    return this.loadedPlugins.flatMap((plugin) => plugin.status === "active" ? plugin.skillPaths ?? [] : []);
-  }
-  getPluginCommandPaths() {
-    return this.loadedPlugins.flatMap((plugin) => plugin.status === "active" ? plugin.commandPaths ?? [] : []);
-  }
-  getPluginInstructions() {
-    return this.loadedPlugins.flatMap(
-      (plugin) => plugin.status === "active" && plugin.instructions ? [plugin.instructions] : []
-    );
-  }
-  async notifyReloadListeners(plugins) {
-    await Promise.all([...this.reloadListeners].map((listener) => Promise.resolve(listener(plugins))));
-  }
-  updatePluginRenderConfigs(plugins) {
-    this.toolRenderConfigs.clear();
-    for (const plugin of plugins) {
-      if (plugin.status !== "active") continue;
-      for (const [toolName, renderConfig] of Object.entries(plugin.renderConfigs ?? {})) {
-        if (!this.toolRenderConfigs.has(toolName)) {
-          this.toolRenderConfigs.set(toolName, renderConfig);
-        }
-      }
-    }
-  }
-  updatePluginTools(nextTools) {
-    for (const name of Object.keys(this.rawPluginTools)) {
-      if (!(name in nextTools)) {
-        delete this.rawPluginTools[name];
-        delete this.pluginTools[name];
-      }
-    }
-    for (const [name, tool] of Object.entries(nextTools)) {
-      this.rawPluginTools[name] = tool;
-      if (!this.pluginTools[name]) {
-        this.pluginTools[name] = this.createLiveToolProxy(name);
-      }
-      this.syncLiveToolProxy(name, tool);
-    }
-  }
-  createLiveToolProxy(toolName) {
-    return {
-      execute: async (...args) => {
-        await this.reloadChangedLocalPlugins();
-        const latestTool = this.rawPluginTools[toolName];
-        if (!latestTool?.execute) {
-          throw new Error(`Plugin tool "${toolName}" is no longer available`);
-        }
-        return latestTool.execute(...args);
-      }
-    };
-  }
-  syncLiveToolProxy(toolName, tool) {
-    const proxy = this.pluginTools[toolName];
-    if (!proxy) return;
-    const mutableProxy = proxy;
-    for (const key of Object.keys(mutableProxy)) {
-      delete mutableProxy[key];
-    }
-    Object.assign(proxy, tool);
-    proxy.execute = this.createLiveToolProxy(toolName).execute;
-  }
-  async reloadChangedLocalPlugins() {
-    for (const plugin of this.loadedPlugins) {
-      if (plugin.source !== "local" || plugin.status !== "active") continue;
-      const entryPath = resolvePluginEntryPath(plugin, this.options);
-      const currentVersion = getEntryVersion(entryPath);
-      if (this.localEntryVersions.get(entryPath) !== currentVersion) {
-        await this.reload();
-        return;
-      }
-    }
-  }
-  updateLocalEntryWatchers(plugins) {
-    const nextEntries = /* @__PURE__ */ new Set();
-    for (const plugin of plugins) {
-      if (plugin.source !== "local" || plugin.status !== "active") continue;
-      let entryPath;
-      let entryVersion;
-      try {
-        entryPath = resolvePluginEntryPath(plugin, this.options);
-        entryVersion = getEntryVersion(entryPath);
-      } catch {
-        continue;
-      }
-      nextEntries.add(entryPath);
-      this.localEntryVersions.set(entryPath, entryVersion);
-      if (this.watchedLocalEntries.has(entryPath)) continue;
-      const watcher = fs.watchFile(entryPath, { interval: 500 }, (current, previous) => {
-        if (current.mtimeMs === previous.mtimeMs) return;
-        void this.reload().catch(() => void 0);
-      });
-      watcher.unref?.();
-      this.watchedLocalEntries.add(entryPath);
-    }
-    for (const entryPath of this.watchedLocalEntries) {
-      if (nextEntries.has(entryPath)) continue;
-      fs.unwatchFile(entryPath);
-      this.watchedLocalEntries.delete(entryPath);
-      this.localEntryVersions.delete(entryPath);
-    }
-  }
-  updateGithubPoller(plugins) {
-    const hasGithubPlugin = plugins.some(
-      (plugin) => plugin.source === "github" && plugin.status !== "inactive" && plugin.status !== "blocked"
-    );
-    if (hasGithubPlugin && !this.githubPollTimer) {
-      this.githubPollTimer = setInterval(() => {
-        void this.pollGithubSourcesForUpdates().catch(() => void 0);
-      }, GITHUB_PLUGIN_POLL_INTERVAL_MS);
-      this.githubPollTimer.unref?.();
-    }
-    if (!hasGithubPlugin && this.githubPollTimer) {
-      clearInterval(this.githubPollTimer);
-      this.githubPollTimer = void 0;
-    }
-  }
-  async pollGithubSourcesForUpdates() {
-    if (this.githubPollInFlight) return this.githubPollInFlight;
-    this.githubPollInFlight = this.pollGithubSourcesForUpdatesOnce().finally(() => {
-      this.githubPollInFlight = void 0;
-    });
-    return this.githubPollInFlight;
-  }
-  async pollGithubSourcesForUpdatesOnce() {
-    const changedCheckouts = /* @__PURE__ */ new Set();
-    const seen = /* @__PURE__ */ new Set();
-    for (const plugin of this.loadedPlugins) {
-      if (plugin.source !== "github" || plugin.status === "inactive" || plugin.status === "blocked") continue;
-      const checkoutPath = this.resolvePluginSourcePath(plugin);
-      if (seen.has(checkoutPath) || !fs.existsSync(path.join(checkoutPath, ".git"))) continue;
-      seen.add(checkoutPath);
-      const before = await this.readGitHead(checkoutPath);
-      const checkoutChanged = await this.refreshGithubCheckout(plugin, checkoutPath, before);
-      const after = await this.readGitHead(checkoutPath);
-      if (checkoutChanged || before !== after) changedCheckouts.add(checkoutPath);
-    }
-    if (changedCheckouts.size === 0) return false;
-    await this.reload();
-    const updatedPluginNames = this.loadedPlugins.filter(
-      (plugin) => plugin.source === "github" && plugin.status !== "inactive" && plugin.status !== "blocked" && changedCheckouts.has(this.resolvePluginSourcePath(plugin))
-    ).map((plugin) => plugin.name ?? plugin.id);
-    await this.notifyGithubUpdateListeners(updatedPluginNames);
-    return true;
-  }
-  async notifyGithubUpdateListeners(pluginNames) {
-    await Promise.all([...this.githubUpdateListeners].map((listener) => Promise.resolve(listener(pluginNames))));
-  }
-  async refreshGithubCheckout(plugin, checkoutPath, currentHead) {
-    await execa("git", ["fetch", "origin"], gitExecOptions(checkoutPath));
-    const upstream = await this.resolveGitUpstream(checkoutPath, plugin.ref);
-    if (!upstream) return false;
-    const [localOnly, remoteOnly] = await this.readGitAheadBehind(checkoutPath, upstream);
-    const hasLocalChanges = await this.hasGitWorkingTreeChanges(checkoutPath);
-    if (localOnly > 0 || hasLocalChanges) {
-      await this.backupGitCheckout(checkoutPath, currentHead, hasLocalChanges);
-    }
-    if (remoteOnly > 0 || localOnly > 0 || hasLocalChanges) {
-      await execa("git", ["reset", "--hard", upstream], gitExecOptions(checkoutPath));
-      try {
-        await installPluginDependenciesForEntry(checkoutPath, plugin.entry);
-        ensureMastraCodePackageLink(getEntryPackageRoot(checkoutPath, plugin.entry));
-      } catch (error) {
-        await execa("git", ["reset", "--hard", currentHead], gitExecOptions(checkoutPath));
-        throw error;
-      }
-      return true;
-    }
-    return false;
-  }
-  async backupGitCheckout(checkoutPath, currentHead, includeWorkingTree) {
-    const backupBranch = this.createGitBackupBranchName(currentHead);
-    if (includeWorkingTree) {
-      const currentBranch = await this.readGitCurrentBranch(checkoutPath);
-      await execa("git", ["switch", "-c", backupBranch], gitExecOptions(checkoutPath));
-      await execa("git", ["add", "-A"], gitExecOptions(checkoutPath));
-      const hasStagedChanges = await this.hasGitStagedChanges(checkoutPath);
-      if (hasStagedChanges) {
-        await execa(
-          "git",
-          [
-            "-c",
-            "user.name=Mastra Code",
-            "-c",
-            "user.email=noreply@mastra.ai",
-            "commit",
-            "-m",
-            "chore: backup local plugin checkout changes"
-          ],
-          gitExecOptions(checkoutPath)
-        );
-      }
-      await this.restoreGitCheckout(checkoutPath, currentBranch, currentHead);
-      return;
-    }
-    await execa("git", ["branch", backupBranch, "HEAD"], gitExecOptions(checkoutPath));
-  }
-  async resolveGitUpstream(cwd, installedRef) {
-    try {
-      const { stdout } = await execa(
-        "git",
-        ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
-        gitExecOptions(cwd)
-      );
-      return stdout.trim();
-    } catch {
-      return installedRef ? void 0 : "origin/main";
-    }
-  }
-  async readGitAheadBehind(cwd, upstream) {
-    const { stdout } = await execa(
-      "git",
-      ["rev-list", "--left-right", "--count", `HEAD...${upstream}`],
-      gitExecOptions(cwd)
-    );
-    const [ahead = "0", behind = "0"] = stdout.trim().split(/\s+/);
-    return [Number(ahead) || 0, Number(behind) || 0];
-  }
-  async hasGitWorkingTreeChanges(cwd) {
-    const { stdout } = await execa("git", ["status", "--porcelain"], gitExecOptions(cwd));
-    return stdout.trim().length > 0;
-  }
-  async hasGitStagedChanges(cwd) {
-    try {
-      await execa("git", ["diff", "--cached", "--quiet"], gitExecOptions(cwd));
-      return false;
-    } catch {
-      return true;
-    }
-  }
-  async restoreGitCheckout(cwd, branch, fallbackHead) {
-    if (branch) {
-      await execa("git", ["switch", branch], gitExecOptions(cwd));
-      return;
-    }
-    await execa("git", ["checkout", fallbackHead], gitExecOptions(cwd));
-  }
-  async readGitCurrentBranch(cwd) {
-    const { stdout } = await execa("git", ["branch", "--show-current"], gitExecOptions(cwd));
-    const branch = stdout.trim();
-    return branch.length > 0 ? branch : void 0;
-  }
-  createGitBackupBranchName(currentHead) {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    return `mastracode/plugin-backup/${timestamp}-${currentHead.slice(0, 8)}`;
-  }
-  resolvePluginSourcePath(plugin) {
-    const paths = getPluginScopePaths(plugin.scope, this.options);
-    return path.isAbsolute(plugin.path) ? plugin.path : path.join(paths.root, plugin.path);
-  }
-  async readGitHead(cwd) {
-    const { stdout } = await execa("git", ["rev-parse", "HEAD"], gitExecOptions(cwd));
-    return stdout.trim();
-  }
-  discoverLocal(searchRoot = ".") {
-    return discoverLocalPlugins(searchRoot, this.options);
-  }
-  async installLocal(localPath, scope, options = {}) {
-    const id = await installLocalPlugin(localPath, scope, { ...this.options, ...options });
-    await this.reload();
-    return id;
-  }
-  async installGithub(url, scope, options = {}) {
-    const id = await installGithubPlugin(url, scope, { ...this.options, ...options });
-    await this.reload();
-    return id;
-  }
-  async setEnabled(pluginId, scope, enabled) {
-    const paths = getPluginScopePaths(scope, this.options);
-    const registry = loadPluginRegistry(paths.registryPath);
-    const record = registry.plugins[pluginId];
-    if (!record) {
-      throw new Error(`Plugin "${pluginId}" is not installed in ${scope} scope`);
-    }
-    savePluginRegistry(paths.registryPath, setPluginRecord(registry, pluginId, { ...record, enabled }));
-    await this.reload();
-  }
-  async setConfigValue(pluginId, scope, key, value) {
-    const paths = getPluginScopePaths(scope, this.options);
-    const registry = loadPluginRegistry(paths.registryPath);
-    const record = registry.plugins[pluginId];
-    if (!record) {
-      throw new Error(`Plugin "${pluginId}" is not installed in ${scope} scope`);
-    }
-    const config = { ...record.config ?? {} };
-    if (value === void 0 || value === "") {
-      delete config[key];
-    } else {
-      config[key] = value;
-    }
-    const nextRecord = { ...record, config: Object.keys(config).length > 0 ? config : void 0 };
-    savePluginRegistry(paths.registryPath, setPluginRecord(registry, pluginId, nextRecord));
-    await this.reload();
-  }
-  async uninstall(pluginId, scope) {
-    const paths = getPluginScopePaths(scope, this.options);
-    const registry = loadPluginRegistry(paths.registryPath);
-    const record = registry.plugins[pluginId];
-    if (!record) {
-      throw new Error(`Plugin "${pluginId}" is not installed in ${scope} scope`);
-    }
-    savePluginRegistry(paths.registryPath, removePluginRecord(registry, pluginId));
-    if (record.source === "github") {
-      const checkoutPath = path.resolve(
-        path.isAbsolute(record.path) ? record.path : path.join(paths.root, record.path)
-      );
-      const githubSourcesPath = path.resolve(paths.sourcesPath, "github");
-      if (isInsideDirectory(checkoutPath, githubSourcesPath)) {
-        fs.rmSync(checkoutPath, { recursive: true, force: true });
-      }
-    }
-    await this.reload();
-  }
+	const stat = fs.statSync(entryPath, { bigint: true });
+	return `${stat.mtimeNs}:${stat.size}`;
 }
-export {
-  PluginManager
+var PluginManager = class {
+	options;
+	loadedPlugins = [];
+	pluginTools = {};
+	rawPluginTools = {};
+	toolRenderConfigs = /* @__PURE__ */ new Map();
+	watchedLocalEntries = /* @__PURE__ */ new Set();
+	localEntryVersions = /* @__PURE__ */ new Map();
+	githubPollTimer;
+	githubPollInFlight;
+	reloadInFlight;
+	reloadListeners = /* @__PURE__ */ new Set();
+	githubUpdateListeners = /* @__PURE__ */ new Set();
+	constructor(options) {
+		this.options = options;
+	}
+	onReload(listener) {
+		this.reloadListeners.add(listener);
+		return () => this.reloadListeners.delete(listener);
+	}
+	/** Notified with the display names of GitHub plugins that were updated by the background poll. */
+	onGithubPluginsUpdated(listener) {
+		this.githubUpdateListeners.add(listener);
+		return () => this.githubUpdateListeners.delete(listener);
+	}
+	async reload() {
+		if (this.reloadInFlight) return this.reloadInFlight;
+		this.reloadInFlight = (async () => {
+			this.loadedPlugins = await loadPlugins(this.options);
+			this.updateLocalEntryWatchers(this.loadedPlugins);
+			this.updateGithubPoller(this.loadedPlugins);
+			this.updatePluginRenderConfigs(this.loadedPlugins);
+			this.updatePluginTools(collectActivePluginTools(this.loadedPlugins));
+			await this.notifyReloadListeners(this.loadedPlugins);
+			return this.loadedPlugins;
+		})().finally(() => {
+			this.reloadInFlight = void 0;
+		});
+		return this.reloadInFlight;
+	}
+	async listPlugins() {
+		if (this.loadedPlugins.length === 0) await this.reload();
+		return this.loadedPlugins;
+	}
+	getLoadedPlugins() {
+		return this.loadedPlugins;
+	}
+	getPluginTools() {
+		return this.pluginTools;
+	}
+	getToolRenderConfig(toolName) {
+		return this.toolRenderConfigs.get(toolName);
+	}
+	getPluginSkillPaths() {
+		return this.loadedPlugins.flatMap((plugin) => plugin.status === "active" ? plugin.skillPaths ?? [] : []);
+	}
+	getPluginCommandPaths() {
+		return this.loadedPlugins.flatMap((plugin) => plugin.status === "active" ? plugin.commandPaths ?? [] : []);
+	}
+	getPluginInstructions() {
+		return this.loadedPlugins.flatMap((plugin) => plugin.status === "active" && plugin.instructions ? [plugin.instructions] : []);
+	}
+	async notifyReloadListeners(plugins) {
+		await Promise.all([...this.reloadListeners].map((listener) => Promise.resolve(listener(plugins))));
+	}
+	updatePluginRenderConfigs(plugins) {
+		this.toolRenderConfigs.clear();
+		for (const plugin of plugins) {
+			if (plugin.status !== "active") continue;
+			for (const [toolName, renderConfig] of Object.entries(plugin.renderConfigs ?? {})) if (!this.toolRenderConfigs.has(toolName)) this.toolRenderConfigs.set(toolName, renderConfig);
+		}
+	}
+	updatePluginTools(nextTools) {
+		for (const name of Object.keys(this.rawPluginTools)) if (!(name in nextTools)) {
+			delete this.rawPluginTools[name];
+			delete this.pluginTools[name];
+		}
+		for (const [name, tool] of Object.entries(nextTools)) {
+			this.rawPluginTools[name] = tool;
+			if (!this.pluginTools[name]) this.pluginTools[name] = this.createLiveToolProxy(name);
+			this.syncLiveToolProxy(name, tool);
+		}
+	}
+	createLiveToolProxy(toolName) {
+		return { execute: async (...args) => {
+			await this.reloadChangedLocalPlugins();
+			const latestTool = this.rawPluginTools[toolName];
+			if (!latestTool?.execute) throw new Error(`Plugin tool "${toolName}" is no longer available`);
+			return latestTool.execute(...args);
+		} };
+	}
+	syncLiveToolProxy(toolName, tool) {
+		const proxy = this.pluginTools[toolName];
+		if (!proxy) return;
+		const mutableProxy = proxy;
+		for (const key of Object.keys(mutableProxy)) delete mutableProxy[key];
+		Object.assign(proxy, tool);
+		proxy.execute = this.createLiveToolProxy(toolName).execute;
+	}
+	async reloadChangedLocalPlugins() {
+		for (const plugin of this.loadedPlugins) {
+			if (plugin.source !== "local" || plugin.status !== "active") continue;
+			const entryPath = resolvePluginEntryPath(plugin, this.options);
+			const currentVersion = getEntryVersion(entryPath);
+			if (this.localEntryVersions.get(entryPath) !== currentVersion) {
+				await this.reload();
+				return;
+			}
+		}
+	}
+	updateLocalEntryWatchers(plugins) {
+		const nextEntries = /* @__PURE__ */ new Set();
+		for (const plugin of plugins) {
+			if (plugin.source !== "local" || plugin.status !== "active") continue;
+			let entryPath;
+			let entryVersion;
+			try {
+				entryPath = resolvePluginEntryPath(plugin, this.options);
+				entryVersion = getEntryVersion(entryPath);
+			} catch {
+				continue;
+			}
+			nextEntries.add(entryPath);
+			this.localEntryVersions.set(entryPath, entryVersion);
+			if (this.watchedLocalEntries.has(entryPath)) continue;
+			fs.watchFile(entryPath, { interval: 500 }, (current, previous) => {
+				if (current.mtimeMs === previous.mtimeMs) return;
+				this.reload().catch(() => void 0);
+			}).unref?.();
+			this.watchedLocalEntries.add(entryPath);
+		}
+		for (const entryPath of this.watchedLocalEntries) {
+			if (nextEntries.has(entryPath)) continue;
+			fs.unwatchFile(entryPath);
+			this.watchedLocalEntries.delete(entryPath);
+			this.localEntryVersions.delete(entryPath);
+		}
+	}
+	updateGithubPoller(plugins) {
+		const hasGithubPlugin = plugins.some((plugin) => plugin.source === "github" && plugin.status !== "inactive" && plugin.status !== "blocked");
+		if (hasGithubPlugin && !this.githubPollTimer) {
+			this.githubPollTimer = setInterval(() => {
+				this.pollGithubSourcesForUpdates().catch(() => void 0);
+			}, GITHUB_PLUGIN_POLL_INTERVAL_MS);
+			this.githubPollTimer.unref?.();
+		}
+		if (!hasGithubPlugin && this.githubPollTimer) {
+			clearInterval(this.githubPollTimer);
+			this.githubPollTimer = void 0;
+		}
+	}
+	async pollGithubSourcesForUpdates() {
+		if (this.githubPollInFlight) return this.githubPollInFlight;
+		this.githubPollInFlight = this.pollGithubSourcesForUpdatesOnce().finally(() => {
+			this.githubPollInFlight = void 0;
+		});
+		return this.githubPollInFlight;
+	}
+	async pollGithubSourcesForUpdatesOnce() {
+		const changedCheckouts = /* @__PURE__ */ new Set();
+		const seen = /* @__PURE__ */ new Set();
+		for (const plugin of this.loadedPlugins) {
+			if (plugin.source !== "github" || plugin.status === "inactive" || plugin.status === "blocked") continue;
+			const checkoutPath = this.resolvePluginSourcePath(plugin);
+			if (seen.has(checkoutPath) || !fs.existsSync(path.join(checkoutPath, ".git"))) continue;
+			seen.add(checkoutPath);
+			const before = await this.readGitHead(checkoutPath);
+			const checkoutChanged = await this.refreshGithubCheckout(plugin, checkoutPath, before);
+			const after = await this.readGitHead(checkoutPath);
+			if (checkoutChanged || before !== after) changedCheckouts.add(checkoutPath);
+		}
+		if (changedCheckouts.size === 0) return false;
+		await this.reload();
+		const updatedPluginNames = this.loadedPlugins.filter((plugin) => plugin.source === "github" && plugin.status !== "inactive" && plugin.status !== "blocked" && changedCheckouts.has(this.resolvePluginSourcePath(plugin))).map((plugin) => plugin.name ?? plugin.id);
+		await this.notifyGithubUpdateListeners(updatedPluginNames);
+		return true;
+	}
+	async notifyGithubUpdateListeners(pluginNames) {
+		await Promise.all([...this.githubUpdateListeners].map((listener) => Promise.resolve(listener(pluginNames))));
+	}
+	async refreshGithubCheckout(plugin, checkoutPath, currentHead) {
+		await execa("git", ["fetch", "origin"], gitExecOptions(checkoutPath));
+		const upstream = await this.resolveGitUpstream(checkoutPath, plugin.ref);
+		if (!upstream) return false;
+		const [localOnly, remoteOnly] = await this.readGitAheadBehind(checkoutPath, upstream);
+		const hasLocalChanges = await this.hasGitWorkingTreeChanges(checkoutPath);
+		if (localOnly > 0 || hasLocalChanges) await this.backupGitCheckout(checkoutPath, currentHead, hasLocalChanges);
+		if (remoteOnly > 0 || localOnly > 0 || hasLocalChanges) {
+			await execa("git", [
+				"reset",
+				"--hard",
+				upstream
+			], gitExecOptions(checkoutPath));
+			try {
+				await installPluginDependenciesForEntry(checkoutPath, plugin.entry);
+				ensureMastraCodePackageLink(getEntryPackageRoot(checkoutPath, plugin.entry));
+			} catch (error) {
+				await execa("git", [
+					"reset",
+					"--hard",
+					currentHead
+				], gitExecOptions(checkoutPath));
+				throw error;
+			}
+			return true;
+		}
+		return false;
+	}
+	async backupGitCheckout(checkoutPath, currentHead, includeWorkingTree) {
+		const backupBranch = this.createGitBackupBranchName(currentHead);
+		if (includeWorkingTree) {
+			const currentBranch = await this.readGitCurrentBranch(checkoutPath);
+			await execa("git", [
+				"switch",
+				"-c",
+				backupBranch
+			], gitExecOptions(checkoutPath));
+			await execa("git", ["add", "-A"], gitExecOptions(checkoutPath));
+			if (await this.hasGitStagedChanges(checkoutPath)) await execa("git", [
+				"-c",
+				"user.name=Mastra Code",
+				"-c",
+				"user.email=noreply@mastra.ai",
+				"commit",
+				"-m",
+				"chore: backup local plugin checkout changes"
+			], gitExecOptions(checkoutPath));
+			await this.restoreGitCheckout(checkoutPath, currentBranch, currentHead);
+			return;
+		}
+		await execa("git", [
+			"branch",
+			backupBranch,
+			"HEAD"
+		], gitExecOptions(checkoutPath));
+	}
+	async resolveGitUpstream(cwd, installedRef) {
+		try {
+			const { stdout } = await execa("git", [
+				"rev-parse",
+				"--abbrev-ref",
+				"--symbolic-full-name",
+				"@{u}"
+			], gitExecOptions(cwd));
+			return stdout.trim();
+		} catch {
+			return installedRef ? void 0 : "origin/main";
+		}
+	}
+	async readGitAheadBehind(cwd, upstream) {
+		const { stdout } = await execa("git", [
+			"rev-list",
+			"--left-right",
+			"--count",
+			`HEAD...${upstream}`
+		], gitExecOptions(cwd));
+		const [ahead = "0", behind = "0"] = stdout.trim().split(/\s+/);
+		return [Number(ahead) || 0, Number(behind) || 0];
+	}
+	async hasGitWorkingTreeChanges(cwd) {
+		const { stdout } = await execa("git", ["status", "--porcelain"], gitExecOptions(cwd));
+		return stdout.trim().length > 0;
+	}
+	async hasGitStagedChanges(cwd) {
+		try {
+			await execa("git", [
+				"diff",
+				"--cached",
+				"--quiet"
+			], gitExecOptions(cwd));
+			return false;
+		} catch {
+			return true;
+		}
+	}
+	async restoreGitCheckout(cwd, branch, fallbackHead) {
+		if (branch) {
+			await execa("git", ["switch", branch], gitExecOptions(cwd));
+			return;
+		}
+		await execa("git", ["checkout", fallbackHead], gitExecOptions(cwd));
+	}
+	async readGitCurrentBranch(cwd) {
+		const { stdout } = await execa("git", ["branch", "--show-current"], gitExecOptions(cwd));
+		const branch = stdout.trim();
+		return branch.length > 0 ? branch : void 0;
+	}
+	createGitBackupBranchName(currentHead) {
+		return `mastracode/plugin-backup/${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${currentHead.slice(0, 8)}`;
+	}
+	resolvePluginSourcePath(plugin) {
+		const paths = getPluginScopePaths(plugin.scope, this.options);
+		return path.isAbsolute(plugin.path) ? plugin.path : path.join(paths.root, plugin.path);
+	}
+	async readGitHead(cwd) {
+		const { stdout } = await execa("git", ["rev-parse", "HEAD"], gitExecOptions(cwd));
+		return stdout.trim();
+	}
+	discoverLocal(searchRoot = ".") {
+		return discoverLocalPlugins(searchRoot, this.options);
+	}
+	async installLocal(localPath, scope, options = {}) {
+		const id = await installLocalPlugin(localPath, scope, {
+			...this.options,
+			...options
+		});
+		await this.reload();
+		return id;
+	}
+	async installGithub(url, scope, options = {}) {
+		const id = await installGithubPlugin(url, scope, {
+			...this.options,
+			...options
+		});
+		await this.reload();
+		return id;
+	}
+	async setEnabled(pluginId, scope, enabled) {
+		const paths = getPluginScopePaths(scope, this.options);
+		const registry = loadPluginRegistry(paths.registryPath);
+		const record = registry.plugins[pluginId];
+		if (!record) throw new Error(`Plugin "${pluginId}" is not installed in ${scope} scope`);
+		savePluginRegistry(paths.registryPath, setPluginRecord(registry, pluginId, {
+			...record,
+			enabled
+		}));
+		await this.reload();
+	}
+	async setConfigValue(pluginId, scope, key, value) {
+		const paths = getPluginScopePaths(scope, this.options);
+		const registry = loadPluginRegistry(paths.registryPath);
+		const record = registry.plugins[pluginId];
+		if (!record) throw new Error(`Plugin "${pluginId}" is not installed in ${scope} scope`);
+		const config = { ...record.config ?? {} };
+		if (value === void 0 || value === "") delete config[key];
+		else config[key] = value;
+		const nextRecord = {
+			...record,
+			config: Object.keys(config).length > 0 ? config : void 0
+		};
+		savePluginRegistry(paths.registryPath, setPluginRecord(registry, pluginId, nextRecord));
+		await this.reload();
+	}
+	async uninstall(pluginId, scope) {
+		const paths = getPluginScopePaths(scope, this.options);
+		const registry = loadPluginRegistry(paths.registryPath);
+		const record = registry.plugins[pluginId];
+		if (!record) throw new Error(`Plugin "${pluginId}" is not installed in ${scope} scope`);
+		savePluginRegistry(paths.registryPath, removePluginRecord(registry, pluginId));
+		if (record.source === "github") {
+			const checkoutPath = path.resolve(path.isAbsolute(record.path) ? record.path : path.join(paths.root, record.path));
+			if (isInsideDirectory(checkoutPath, path.resolve(paths.sourcesPath, "github"))) fs.rmSync(checkoutPath, {
+				recursive: true,
+				force: true
+			});
+		}
+		await this.reload();
+	}
 };
+//#endregion
+export { PluginManager };
+
 //# sourceMappingURL=manager.js.map