@dexto/core 1.1.4 → 1.1.6

package/dist/agent/registry/registry.cjs

@@ -0,0 +1,291 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var registry_exports = {};
+__export(registry_exports, {
+  LocalAgentRegistry: () => LocalAgentRegistry,
+  getAgentRegistry: () => getAgentRegistry
+});
+module.exports = __toCommonJS(registry_exports);
+var import_fs = require("fs");
+var import_fs2 = require("fs");
+var import_path = __toESM(require("path"), 1);
+var import_logger = require("../../logger/index.cjs");
+var import_path2 = require("../../utils/path.cjs");
+var import_loader = require("../../preferences/loader.cjs");
+var import_writer = require("../../config/writer.cjs");
+var import_types = require("./types.js");
+var import_errors = require("./errors.js");
+let cachedRegistry = null;
+class LocalAgentRegistry {
+  _registry = null;
+  /**
+   * Lazy load registry from JSON file
+   */
+  getRegistry() {
+    if (this._registry === null) {
+      this._registry = this.loadRegistry();
+    }
+    return this._registry;
+  }
+  /**
+   * Load registry from bundled JSON file
+   * Uses fail-fast approach - throws RegistryError for any loading issues
+   */
+  loadRegistry() {
+    let jsonPath;
+    try {
+      jsonPath = (0, import_path2.resolveBundledScript)("agents/agent-registry.json");
+    } catch (error) {
+      throw import_errors.RegistryError.registryNotFound(
+        "agents/agent-registry.json",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    if (!(0, import_fs.existsSync)(jsonPath)) {
+      throw import_errors.RegistryError.registryNotFound(jsonPath, "File doesn't exist");
+    }
+    try {
+      const jsonData = (0, import_fs.readFileSync)(jsonPath, "utf-8");
+      const rawRegistry = JSON.parse(jsonData);
+      return import_types.RegistrySchema.parse(rawRegistry);
+    } catch (error) {
+      throw import_errors.RegistryError.registryParseError(
+        jsonPath,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Check if agent exists in registry
+   */
+  hasAgent(name) {
+    const registry = this.getRegistry();
+    return name in registry.agents;
+  }
+  /**
+   * Get available agents with their metadata from registry
+   */
+  getAvailableAgents() {
+    const registry = this.getRegistry();
+    return registry.agents;
+  }
+  /**
+   * Resolve main config file for installed agent
+   * Handles both directory agents (with main field) and single-file agents
+   */
+  resolveMainConfig(agentDir, agentName) {
+    const registry = this.getRegistry();
+    const agentData = registry.agents[agentName];
+    if (!agentData) {
+      const available = Object.keys(registry.agents);
+      throw import_errors.RegistryError.agentNotFound(agentName, available);
+    }
+    if (agentData.source.endsWith("/")) {
+      if (!agentData.main) {
+        throw import_errors.RegistryError.agentInvalidEntry(
+          agentName,
+          "directory entry missing main field"
+        );
+      }
+      const mainConfigPath = import_path.default.join(agentDir, agentData.main);
+      if (!(0, import_fs.existsSync)(mainConfigPath)) {
+        throw import_errors.RegistryError.mainConfigMissing(agentName, mainConfigPath);
+      }
+      return mainConfigPath;
+    } else {
+      const filename = import_path.default.basename(agentData.source);
+      const configPath = import_path.default.join(agentDir, filename);
+      if (!(0, import_fs.existsSync)(configPath)) {
+        throw import_errors.RegistryError.configNotFound(configPath);
+      }
+      return configPath;
+    }
+  }
+  /**
+   * Install agent atomically using temp + rename pattern
+   * @param agentName Name of the agent to install
+   * @param injectPreferences Whether to inject global preferences into installed agent (default: true)
+   */
+  async installAgent(agentName, injectPreferences = true) {
+    import_logger.logger.info(`Installing agent: ${agentName}`);
+    const registry = this.getRegistry();
+    const agentData = registry.agents[agentName];
+    if (!agentData) {
+      const available = Object.keys(registry.agents);
+      throw import_errors.RegistryError.agentNotFound(agentName, available);
+    }
+    const globalAgentsDir = (0, import_path2.getDextoGlobalPath)("agents");
+    const targetDir = import_path.default.join(globalAgentsDir, agentName);
+    if ((0, import_fs.existsSync)(targetDir)) {
+      import_logger.logger.info(`Agent '${agentName}' already installed`);
+      return this.resolveMainConfig(targetDir, agentName);
+    }
+    await import_fs2.promises.mkdir(globalAgentsDir, { recursive: true });
+    const sourcePath = (0, import_path2.resolveBundledScript)(`agents/${agentData.source}`);
+    const tempDir = `${targetDir}.tmp.${Date.now()}`;
+    try {
+      if (agentData.source.endsWith("/")) {
+        await (0, import_path2.copyDirectory)(sourcePath, tempDir);
+      } else {
+        await import_fs2.promises.mkdir(tempDir, { recursive: true });
+        const targetFile = import_path.default.join(tempDir, import_path.default.basename(sourcePath));
+        await import_fs2.promises.copyFile(sourcePath, targetFile);
+      }
+      const mainConfigPath = this.resolveMainConfig(tempDir, agentName);
+      if (!(0, import_fs.existsSync)(mainConfigPath)) {
+        throw import_errors.RegistryError.installationValidationFailed(agentName, mainConfigPath);
+      }
+      await import_fs2.promises.rename(tempDir, targetDir);
+      import_logger.logger.info(`\u2713 Installed agent '${agentName}' to ${targetDir}`);
+      if (injectPreferences) {
+        try {
+          const preferences = await (0, import_loader.loadGlobalPreferences)();
+          await (0, import_writer.writePreferencesToAgent)(targetDir, preferences);
+          import_logger.logger.info(`\u2713 Applied global preferences to installed agent '${agentName}'`);
+        } catch (error) {
+          import_logger.logger.warn(
+            `Failed to inject preferences to '${agentName}': ${error instanceof Error ? error.message : String(error)}`
+          );
+          console.log(
+            `\u26A0\uFE0F  Warning: Could not apply preferences to '${agentName}' - agent will use bundled settings`
+          );
+        }
+      } else {
+        import_logger.logger.info(
+          `Skipped preference injection for '${agentName}' (injectPreferences=false)`
+        );
+      }
+      return this.resolveMainConfig(targetDir, agentName);
+    } catch (error) {
+      try {
+        if ((0, import_fs.existsSync)(tempDir)) {
+          await import_fs2.promises.rm(tempDir, { recursive: true, force: true });
+        }
+      } catch (cleanupError) {
+        import_logger.logger.error(
+          `Failed to clean up temp directory: ${cleanupError}. Skipping cleanup...`
+        );
+      }
+      throw import_errors.RegistryError.installationFailed(
+        agentName,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Resolve a registry agent name to a config path
+   * NOTE: Only handles registry names, not file paths (routing done in loadAgentConfig)
+   * Handles installing agent if needed
+   * @param agentName Name of the agent to resolve
+   * @param autoInstall Whether to automatically install missing agents from registry (default: true)
+   * @param injectPreferences Whether to inject preferences during auto-installation (default: true)
+   */
+  async resolveAgent(agentName, autoInstall = true, injectPreferences = true) {
+    import_logger.logger.debug(`Resolving registry agent: ${agentName}`);
+    const globalAgentsDir = (0, import_path2.getDextoGlobalPath)("agents");
+    const installedPath = import_path.default.join(globalAgentsDir, agentName);
+    if ((0, import_fs.existsSync)(installedPath)) {
+      const mainConfig = this.resolveMainConfig(installedPath, agentName);
+      import_logger.logger.debug(`Resolved installed agent '${agentName}' to: ${mainConfig}`);
+      return mainConfig;
+    }
+    import_logger.logger.debug(`Agent '${agentName}' not found in installed path: ${installedPath}`);
+    if (this.hasAgent(agentName)) {
+      if (autoInstall) {
+        import_logger.logger.info(`Installing agent '${agentName}' from registry...`);
+        return await this.installAgent(agentName, injectPreferences);
+      } else {
+        const registry2 = this.getRegistry();
+        const available2 = Object.keys(registry2.agents);
+        throw import_errors.RegistryError.agentNotInstalledAutoInstallDisabled(agentName, available2);
+      }
+    }
+    const registry = this.getRegistry();
+    const available = Object.keys(registry.agents);
+    throw import_errors.RegistryError.agentNotFound(agentName, available);
+  }
+  /**
+   * Get list of currently installed agents
+   */
+  async getInstalledAgents() {
+    const globalAgentsDir = (0, import_path2.getDextoGlobalPath)("agents");
+    if (!(0, import_fs.existsSync)(globalAgentsDir)) {
+      return [];
+    }
+    try {
+      const entries = await import_fs2.promises.readdir(globalAgentsDir, { withFileTypes: true });
+      return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => !name.startsWith(".tmp") && !name.includes(".tmp."));
+    } catch (error) {
+      import_logger.logger.error(`Failed to read installed agents directory: ${error}`);
+      return [];
+    }
+  }
+  /**
+   * Check if an agent is safe to uninstall (not the default-agent which is critical)
+   */
+  isAgentSafeToUninstall(agentName) {
+    return agentName !== "default-agent";
+  }
+  /**
+   * Uninstall an agent by removing its directory
+   * @param agentName Name of the agent to uninstall
+   * @param force Whether to force uninstall even if agent is protected (default: false)
+   */
+  async uninstallAgent(agentName, force = false) {
+    const globalAgentsDir = (0, import_path2.getDextoGlobalPath)("agents");
+    const agentDir = import_path.default.join(globalAgentsDir, agentName);
+    import_logger.logger.info(`Uninstalling agent: ${agentName} from ${agentDir}`);
+    if (!(0, import_fs.existsSync)(agentDir)) {
+      throw import_errors.RegistryError.agentNotInstalled(agentName);
+    }
+    if (!force && !this.isAgentSafeToUninstall(agentName)) {
+      throw import_errors.RegistryError.agentProtected(agentName);
+    }
+    try {
+      await import_fs2.promises.rm(agentDir, { recursive: true, force: true });
+      import_logger.logger.info(`\u2713 Removed agent '${agentName}' from ${agentDir}`);
+    } catch (error) {
+      throw import_errors.RegistryError.uninstallationFailed(
+        agentName,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+}
+function getAgentRegistry() {
+  if (cachedRegistry === null) {
+    cachedRegistry = new LocalAgentRegistry();
+  }
+  return cachedRegistry;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LocalAgentRegistry,
+  getAgentRegistry
+});

package/dist/agent/registry/registry.d.cts

@@ -0,0 +1,67 @@
+import { AgentRegistry, Registry, AgentRegistryEntry } from './types.cjs';
+import 'zod';
+
+/**
+ * Local agent registry implementation
+ * TODO: MOVE THIS INTO CLI WHERE IT IS USED, and add posthog instrumentation for install/uninstall/resolve/etc, similar to manual install command
+ */
+declare class LocalAgentRegistry implements AgentRegistry {
+    private _registry;
+    /**
+     * Lazy load registry from JSON file
+     */
+    getRegistry(): Registry;
+    /**
+     * Load registry from bundled JSON file
+     * Uses fail-fast approach - throws RegistryError for any loading issues
+     */
+    private loadRegistry;
+    /**
+     * Check if agent exists in registry
+     */
+    hasAgent(name: string): boolean;
+    /**
+     * Get available agents with their metadata from registry
+     */
+    getAvailableAgents(): Record<string, AgentRegistryEntry>;
+    /**
+     * Resolve main config file for installed agent
+     * Handles both directory agents (with main field) and single-file agents
+     */
+    resolveMainConfig(agentDir: string, agentName: string): string;
+    /**
+     * Install agent atomically using temp + rename pattern
+     * @param agentName Name of the agent to install
+     * @param injectPreferences Whether to inject global preferences into installed agent (default: true)
+     */
+    installAgent(agentName: string, injectPreferences?: boolean): Promise<string>;
+    /**
+     * Resolve a registry agent name to a config path
+     * NOTE: Only handles registry names, not file paths (routing done in loadAgentConfig)
+     * Handles installing agent if needed
+     * @param agentName Name of the agent to resolve
+     * @param autoInstall Whether to automatically install missing agents from registry (default: true)
+     * @param injectPreferences Whether to inject preferences during auto-installation (default: true)
+     */
+    resolveAgent(agentName: string, autoInstall?: boolean, injectPreferences?: boolean): Promise<string>;
+    /**
+     * Get list of currently installed agents
+     */
+    getInstalledAgents(): Promise<string[]>;
+    /**
+     * Check if an agent is safe to uninstall (not the default-agent which is critical)
+     */
+    private isAgentSafeToUninstall;
+    /**
+     * Uninstall an agent by removing its directory
+     * @param agentName Name of the agent to uninstall
+     * @param force Whether to force uninstall even if agent is protected (default: false)
+     */
+    uninstallAgent(agentName: string, force?: boolean): Promise<void>;
+}
+/**
+ * Get cached registry instance (singleton pattern)
+ */
+declare function getAgentRegistry(): LocalAgentRegistry;
+
+export { LocalAgentRegistry, getAgentRegistry };

package/dist/agent/registry/registry.d.ts

@@ -0,0 +1,67 @@
+import { AgentRegistry, Registry, AgentRegistryEntry } from './types.js';
+import 'zod';
+
+/**
+ * Local agent registry implementation
+ * TODO: MOVE THIS INTO CLI WHERE IT IS USED, and add posthog instrumentation for install/uninstall/resolve/etc, similar to manual install command
+ */
+declare class LocalAgentRegistry implements AgentRegistry {
+    private _registry;
+    /**
+     * Lazy load registry from JSON file
+     */
+    getRegistry(): Registry;
+    /**
+     * Load registry from bundled JSON file
+     * Uses fail-fast approach - throws RegistryError for any loading issues
+     */
+    private loadRegistry;
+    /**
+     * Check if agent exists in registry
+     */
+    hasAgent(name: string): boolean;
+    /**
+     * Get available agents with their metadata from registry
+     */
+    getAvailableAgents(): Record<string, AgentRegistryEntry>;
+    /**
+     * Resolve main config file for installed agent
+     * Handles both directory agents (with main field) and single-file agents
+     */
+    resolveMainConfig(agentDir: string, agentName: string): string;
+    /**
+     * Install agent atomically using temp + rename pattern
+     * @param agentName Name of the agent to install
+     * @param injectPreferences Whether to inject global preferences into installed agent (default: true)
+     */
+    installAgent(agentName: string, injectPreferences?: boolean): Promise<string>;
+    /**
+     * Resolve a registry agent name to a config path
+     * NOTE: Only handles registry names, not file paths (routing done in loadAgentConfig)
+     * Handles installing agent if needed
+     * @param agentName Name of the agent to resolve
+     * @param autoInstall Whether to automatically install missing agents from registry (default: true)
+     * @param injectPreferences Whether to inject preferences during auto-installation (default: true)
+     */
+    resolveAgent(agentName: string, autoInstall?: boolean, injectPreferences?: boolean): Promise<string>;
+    /**
+     * Get list of currently installed agents
+     */
+    getInstalledAgents(): Promise<string[]>;
+    /**
+     * Check if an agent is safe to uninstall (not the default-agent which is critical)
+     */
+    private isAgentSafeToUninstall;
+    /**
+     * Uninstall an agent by removing its directory
+     * @param agentName Name of the agent to uninstall
+     * @param force Whether to force uninstall even if agent is protected (default: false)
+     */
+    uninstallAgent(agentName: string, force?: boolean): Promise<void>;
+}
+/**
+ * Get cached registry instance (singleton pattern)
+ */
+declare function getAgentRegistry(): LocalAgentRegistry;
+
+export { LocalAgentRegistry, getAgentRegistry };

package/dist/agent/registry/registry.js

@@ -0,0 +1,256 @@
+import { existsSync, readFileSync } from "fs";
+import { promises as fs } from "fs";
+import path from "path";
+import { logger } from "../../logger/index.js";
+import { resolveBundledScript, getDextoGlobalPath, copyDirectory } from "../../utils/path.js";
+import { loadGlobalPreferences } from "../../preferences/loader.js";
+import { writePreferencesToAgent } from "../../config/writer.js";
+import { RegistrySchema } from "./types.js";
+import { RegistryError } from "./errors.js";
+let cachedRegistry = null;
+class LocalAgentRegistry {
+  _registry = null;
+  /**
+   * Lazy load registry from JSON file
+   */
+  getRegistry() {
+    if (this._registry === null) {
+      this._registry = this.loadRegistry();
+    }
+    return this._registry;
+  }
+  /**
+   * Load registry from bundled JSON file
+   * Uses fail-fast approach - throws RegistryError for any loading issues
+   */
+  loadRegistry() {
+    let jsonPath;
+    try {
+      jsonPath = resolveBundledScript("agents/agent-registry.json");
+    } catch (error) {
+      throw RegistryError.registryNotFound(
+        "agents/agent-registry.json",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    if (!existsSync(jsonPath)) {
+      throw RegistryError.registryNotFound(jsonPath, "File doesn't exist");
+    }
+    try {
+      const jsonData = readFileSync(jsonPath, "utf-8");
+      const rawRegistry = JSON.parse(jsonData);
+      return RegistrySchema.parse(rawRegistry);
+    } catch (error) {
+      throw RegistryError.registryParseError(
+        jsonPath,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Check if agent exists in registry
+   */
+  hasAgent(name) {
+    const registry = this.getRegistry();
+    return name in registry.agents;
+  }
+  /**
+   * Get available agents with their metadata from registry
+   */
+  getAvailableAgents() {
+    const registry = this.getRegistry();
+    return registry.agents;
+  }
+  /**
+   * Resolve main config file for installed agent
+   * Handles both directory agents (with main field) and single-file agents
+   */
+  resolveMainConfig(agentDir, agentName) {
+    const registry = this.getRegistry();
+    const agentData = registry.agents[agentName];
+    if (!agentData) {
+      const available = Object.keys(registry.agents);
+      throw RegistryError.agentNotFound(agentName, available);
+    }
+    if (agentData.source.endsWith("/")) {
+      if (!agentData.main) {
+        throw RegistryError.agentInvalidEntry(
+          agentName,
+          "directory entry missing main field"
+        );
+      }
+      const mainConfigPath = path.join(agentDir, agentData.main);
+      if (!existsSync(mainConfigPath)) {
+        throw RegistryError.mainConfigMissing(agentName, mainConfigPath);
+      }
+      return mainConfigPath;
+    } else {
+      const filename = path.basename(agentData.source);
+      const configPath = path.join(agentDir, filename);
+      if (!existsSync(configPath)) {
+        throw RegistryError.configNotFound(configPath);
+      }
+      return configPath;
+    }
+  }
+  /**
+   * Install agent atomically using temp + rename pattern
+   * @param agentName Name of the agent to install
+   * @param injectPreferences Whether to inject global preferences into installed agent (default: true)
+   */
+  async installAgent(agentName, injectPreferences = true) {
+    logger.info(`Installing agent: ${agentName}`);
+    const registry = this.getRegistry();
+    const agentData = registry.agents[agentName];
+    if (!agentData) {
+      const available = Object.keys(registry.agents);
+      throw RegistryError.agentNotFound(agentName, available);
+    }
+    const globalAgentsDir = getDextoGlobalPath("agents");
+    const targetDir = path.join(globalAgentsDir, agentName);
+    if (existsSync(targetDir)) {
+      logger.info(`Agent '${agentName}' already installed`);
+      return this.resolveMainConfig(targetDir, agentName);
+    }
+    await fs.mkdir(globalAgentsDir, { recursive: true });
+    const sourcePath = resolveBundledScript(`agents/${agentData.source}`);
+    const tempDir = `${targetDir}.tmp.${Date.now()}`;
+    try {
+      if (agentData.source.endsWith("/")) {
+        await copyDirectory(sourcePath, tempDir);
+      } else {
+        await fs.mkdir(tempDir, { recursive: true });
+        const targetFile = path.join(tempDir, path.basename(sourcePath));
+        await fs.copyFile(sourcePath, targetFile);
+      }
+      const mainConfigPath = this.resolveMainConfig(tempDir, agentName);
+      if (!existsSync(mainConfigPath)) {
+        throw RegistryError.installationValidationFailed(agentName, mainConfigPath);
+      }
+      await fs.rename(tempDir, targetDir);
+      logger.info(`\u2713 Installed agent '${agentName}' to ${targetDir}`);
+      if (injectPreferences) {
+        try {
+          const preferences = await loadGlobalPreferences();
+          await writePreferencesToAgent(targetDir, preferences);
+          logger.info(`\u2713 Applied global preferences to installed agent '${agentName}'`);
+        } catch (error) {
+          logger.warn(
+            `Failed to inject preferences to '${agentName}': ${error instanceof Error ? error.message : String(error)}`
+          );
+          console.log(
+            `\u26A0\uFE0F  Warning: Could not apply preferences to '${agentName}' - agent will use bundled settings`
+          );
+        }
+      } else {
+        logger.info(
+          `Skipped preference injection for '${agentName}' (injectPreferences=false)`
+        );
+      }
+      return this.resolveMainConfig(targetDir, agentName);
+    } catch (error) {
+      try {
+        if (existsSync(tempDir)) {
+          await fs.rm(tempDir, { recursive: true, force: true });
+        }
+      } catch (cleanupError) {
+        logger.error(
+          `Failed to clean up temp directory: ${cleanupError}. Skipping cleanup...`
+        );
+      }
+      throw RegistryError.installationFailed(
+        agentName,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Resolve a registry agent name to a config path
+   * NOTE: Only handles registry names, not file paths (routing done in loadAgentConfig)
+   * Handles installing agent if needed
+   * @param agentName Name of the agent to resolve
+   * @param autoInstall Whether to automatically install missing agents from registry (default: true)
+   * @param injectPreferences Whether to inject preferences during auto-installation (default: true)
+   */
+  async resolveAgent(agentName, autoInstall = true, injectPreferences = true) {
+    logger.debug(`Resolving registry agent: ${agentName}`);
+    const globalAgentsDir = getDextoGlobalPath("agents");
+    const installedPath = path.join(globalAgentsDir, agentName);
+    if (existsSync(installedPath)) {
+      const mainConfig = this.resolveMainConfig(installedPath, agentName);
+      logger.debug(`Resolved installed agent '${agentName}' to: ${mainConfig}`);
+      return mainConfig;
+    }
+    logger.debug(`Agent '${agentName}' not found in installed path: ${installedPath}`);
+    if (this.hasAgent(agentName)) {
+      if (autoInstall) {
+        logger.info(`Installing agent '${agentName}' from registry...`);
+        return await this.installAgent(agentName, injectPreferences);
+      } else {
+        const registry2 = this.getRegistry();
+        const available2 = Object.keys(registry2.agents);
+        throw RegistryError.agentNotInstalledAutoInstallDisabled(agentName, available2);
+      }
+    }
+    const registry = this.getRegistry();
+    const available = Object.keys(registry.agents);
+    throw RegistryError.agentNotFound(agentName, available);
+  }
+  /**
+   * Get list of currently installed agents
+   */
+  async getInstalledAgents() {
+    const globalAgentsDir = getDextoGlobalPath("agents");
+    if (!existsSync(globalAgentsDir)) {
+      return [];
+    }
+    try {
+      const entries = await fs.readdir(globalAgentsDir, { withFileTypes: true });
+      return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => !name.startsWith(".tmp") && !name.includes(".tmp."));
+    } catch (error) {
+      logger.error(`Failed to read installed agents directory: ${error}`);
+      return [];
+    }
+  }
+  /**
+   * Check if an agent is safe to uninstall (not the default-agent which is critical)
+   */
+  isAgentSafeToUninstall(agentName) {
+    return agentName !== "default-agent";
+  }
+  /**
+   * Uninstall an agent by removing its directory
+   * @param agentName Name of the agent to uninstall
+   * @param force Whether to force uninstall even if agent is protected (default: false)
+   */
+  async uninstallAgent(agentName, force = false) {
+    const globalAgentsDir = getDextoGlobalPath("agents");
+    const agentDir = path.join(globalAgentsDir, agentName);
+    logger.info(`Uninstalling agent: ${agentName} from ${agentDir}`);
+    if (!existsSync(agentDir)) {
+      throw RegistryError.agentNotInstalled(agentName);
+    }
+    if (!force && !this.isAgentSafeToUninstall(agentName)) {
+      throw RegistryError.agentProtected(agentName);
+    }
+    try {
+      await fs.rm(agentDir, { recursive: true, force: true });
+      logger.info(`\u2713 Removed agent '${agentName}' from ${agentDir}`);
+    } catch (error) {
+      throw RegistryError.uninstallationFailed(
+        agentName,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+}
+function getAgentRegistry() {
+  if (cachedRegistry === null) {
+    cachedRegistry = new LocalAgentRegistry();
+  }
+  return cachedRegistry;
+}
+export {
+  LocalAgentRegistry,
+  getAgentRegistry
+};