@dexto/core 1.1.10 → 1.2.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/agent/registry/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAI1D;;;GAGG;AACH,qBAAa,aAAa;IAEtB,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE;;;;IAW/D,MAAM,CAAC,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;;;;IAWxD,MAAM,CAAC,kBAAkB,CAAC,OAAO,EAAE,MAAM;;;IAWzC,MAAM,CAAC,uBAAuB,CAAC,OAAO,EAAE,MAAM;;;;IAY9C,MAAM,CAAC,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;IAWxD,MAAM,CAAC,4BAA4B,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;;;;IAYxE,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,MAAM;;;IAWxC,MAAM,CAAC,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;;;;IAY9D,MAAM,CAAC,iBAAiB,CAAC,OAAO,EAAE,MAAM;;;IAWxC,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM;;;IAWrC,MAAM,CAAC,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;IAY1D,MAAM,CAAC,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;IAW3D,MAAM,CAAC,kBAAkB,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;IAW7D,MAAM,CAAC,kBAAkB,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;IAY7D,MAAM,CAAC,oCAAoC,CAAC,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE;;;;CAUzF"}

package/dist/agent/registry/errors.js

@@ -1,46 +1,67 @@
+import "../../chunk-C6A6W6XS.js";
 import { DextoRuntimeError } from "../../errors/index.js";
 import { ErrorScope, ErrorType } from "../../errors/types.js";
 import { RegistryErrorCode } from "./error-codes.js";
 class RegistryError {
   // Agent lookup errors
-  static agentNotFound(agentName, availableAgents) {
+  static agentNotFound(agentId, availableAgents) {
     return new DextoRuntimeError(
       RegistryErrorCode.AGENT_NOT_FOUND,
       ErrorScope.AGENT_REGISTRY,
       ErrorType.USER,
-      `Agent '${agentName}' not found in registry`,
-      { agentName, availableAgents },
+      `Agent '${agentId}' not found in registry`,
+      { agentId, availableAgents },
       `Available agents: ${availableAgents.join(", ")}. Use a file path for custom agents.`
     );
   }
-  static agentInvalidEntry(agentName, reason) {
+  static agentInvalidEntry(agentId, reason) {
     return new DextoRuntimeError(
       RegistryErrorCode.AGENT_INVALID_ENTRY,
       ErrorScope.AGENT_REGISTRY,
       ErrorType.SYSTEM,
-      `Registry entry for '${agentName}' is invalid: ${reason}`,
-      { agentName, reason },
+      `Registry entry for '${agentId}' is invalid: ${reason}`,
+      { agentId, reason },
       "This indicates a problem with the agent registry - please report this issue"
     );
   }
+  static agentAlreadyExists(agentId) {
+    return new DextoRuntimeError(
+      RegistryErrorCode.AGENT_ALREADY_EXISTS,
+      ErrorScope.AGENT_REGISTRY,
+      ErrorType.USER,
+      `Agent '${agentId}' already exists in user registry`,
+      { agentId },
+      "Choose a different name or uninstall the existing agent first"
+    );
+  }
+  static customAgentNameConflict(agentId) {
+    return new DextoRuntimeError(
+      RegistryErrorCode.AGENT_ALREADY_EXISTS,
+      ErrorScope.AGENT_REGISTRY,
+      ErrorType.USER,
+      `Cannot create custom agent '${agentId}': name conflicts with builtin agent`,
+      { agentId, conflictType: "builtin" },
+      "Choose a different name for your custom agent"
+    );
+  }
   // Installation errors
-  static installationFailed(agentName, cause) {
+  static installationFailed(agentId, cause) {
     return new DextoRuntimeError(
       RegistryErrorCode.INSTALLATION_FAILED,
       ErrorScope.AGENT_REGISTRY,
       ErrorType.SYSTEM,
-      `Failed to install agent '${agentName}': ${cause}`,
-      { agentName, cause },
+      `Failed to install agent '${agentId}': ${cause}`,
+      { agentId, cause },
       "Check network connection and available disk space"
     );
   }
-  static installationValidationFailed(agentName, missingPath) {
+  static installationValidationFailed(agentId, missingPath) {
     return new DextoRuntimeError(
       RegistryErrorCode.INSTALLATION_VALIDATION_FAILED,
       ErrorScope.AGENT_REGISTRY,
       ErrorType.SYSTEM,
-      `Installation validation failed for '${agentName}': missing main config`,
-      { agentName, missingPath },
+      `Installation validation failed for '${agentId}': missing main config`,
+      { agentId, missingPath },
       "This indicates a problem with the agent bundle - please report this issue"
     );
   }
@@ -55,44 +76,44 @@ class RegistryError {
       "This indicates a problem with the agent installation"
     );
   }
-  static mainConfigMissing(agentName, expectedPath) {
+  static mainConfigMissing(agentId, expectedPath) {
     return new DextoRuntimeError(
       RegistryErrorCode.MAIN_CONFIG_MISSING,
       ErrorScope.AGENT_REGISTRY,
       ErrorType.SYSTEM,
-      `Main config file not found for agent '${agentName}': ${expectedPath}`,
-      { agentName, expectedPath },
+      `Main config file not found for agent '${agentId}': ${expectedPath}`,
+      { agentId, expectedPath },
       "This indicates a problem with the agent bundle structure"
     );
   }
   // Uninstallation errors
-  static agentNotInstalled(agentName) {
+  static agentNotInstalled(agentId) {
     return new DextoRuntimeError(
       RegistryErrorCode.AGENT_NOT_INSTALLED,
       ErrorScope.AGENT_REGISTRY,
       ErrorType.USER,
-      `Agent '${agentName}' is not installed`,
-      { agentName },
+      `Agent '${agentId}' is not installed`,
+      { agentId },
       'Use "dexto list-agents --installed" to see installed agents'
     );
   }
-  static agentProtected(agentName) {
+  static agentProtected(agentId) {
     return new DextoRuntimeError(
       RegistryErrorCode.AGENT_PROTECTED,
       ErrorScope.AGENT_REGISTRY,
       ErrorType.USER,
-      `Agent '${agentName}' is protected and cannot be uninstalled. Use --force to override (not recommended for critical agents)`,
-      { agentName },
+      `Agent '${agentId}' is protected and cannot be uninstalled. Use --force to override (not recommended for critical agents)`,
+      { agentId },
       "Use --force to override (not recommended for critical agents)"
     );
   }
-  static uninstallationFailed(agentName, cause) {
+  static uninstallationFailed(agentId, cause) {
     return new DextoRuntimeError(
       RegistryErrorCode.UNINSTALLATION_FAILED,
       ErrorScope.AGENT_REGISTRY,
       ErrorType.SYSTEM,
-      `Failed to uninstall agent '${agentName}': ${cause}`,
-      { agentName, cause },
+      `Failed to uninstall agent '${agentId}': ${cause}`,
+      { agentId, cause },
       "Check file permissions and ensure no processes are using the agent"
     );
   }
@@ -117,15 +138,25 @@ class RegistryError {
       "This indicates a corrupted registry file - please reinstall Dexto"
     );
   }
+  static registryWriteError(registryPath, cause) {
+    return new DextoRuntimeError(
+      RegistryErrorCode.REGISTRY_WRITE_ERROR,
+      ErrorScope.AGENT_REGISTRY,
+      ErrorType.SYSTEM,
+      `Failed to save agent registry to ${registryPath}: ${cause}`,
+      { registryPath, cause },
+      "Check file permissions and available disk space"
+    );
+  }
   // Auto-install control errors
-  static agentNotInstalledAutoInstallDisabled(agentName, availableAgents) {
+  static agentNotInstalledAutoInstallDisabled(agentId, availableAgents) {
     return new DextoRuntimeError(
       RegistryErrorCode.AGENT_NOT_INSTALLED_AUTO_INSTALL_DISABLED,
       ErrorScope.AGENT_REGISTRY,
       ErrorType.USER,
-      `Agent '${agentName}' is not installed locally and auto-install is disabled`,
-      { agentName, availableAgents },
-      `Use 'dexto install ${agentName}' to install it manually, or use a file path for custom agents`
+      `Agent '${agentId}' is not installed locally and auto-install is disabled`,
+      { agentId, availableAgents },
+      `Use 'dexto install ${agentId}' to install it manually, or use a file path for custom agents`
     );
   }
 }

package/dist/agent/registry/registry.cjs

@@ -41,6 +41,7 @@ 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");
+var import_user_registry = require("./user-registry.js");
 let cachedRegistry = null;
 class LocalAgentRegistry {
   _registry = null;
@@ -54,7 +55,7 @@ class LocalAgentRegistry {
     return this._registry;
   }
   /**
-   * Load registry from bundled JSON file
+   * Load and merge bundled + user registries
    * Uses fail-fast approach - throws RegistryError for any loading issues
    */
   loadRegistry() {
@@ -70,23 +71,30 @@ class LocalAgentRegistry {
     if (!(0, import_fs.existsSync)(jsonPath)) {
       throw import_errors.RegistryError.registryNotFound(jsonPath, "File doesn't exist");
     }
+    let bundledRegistry;
     try {
       const jsonData = (0, import_fs.readFileSync)(jsonPath, "utf-8");
       const rawRegistry = JSON.parse(jsonData);
-      return import_types.RegistrySchema.parse(rawRegistry);
+      bundledRegistry = import_types.RegistrySchema.parse((0, import_types.normalizeRegistryJson)(rawRegistry));
     } catch (error) {
       throw import_errors.RegistryError.registryParseError(
         jsonPath,
         error instanceof Error ? error.message : String(error)
       );
     }
+    const userRegistry = (0, import_user_registry.loadUserRegistry)();
+    const merged = (0, import_user_registry.mergeRegistries)(bundledRegistry, userRegistry);
+    import_logger.logger.debug(
+      `Loaded registry: ${Object.keys(bundledRegistry.agents).length} bundled, ${Object.keys(userRegistry.agents).length} custom`
+    );
+    return merged;
   }
   /**
-   * Check if agent exists in registry
+   * Check if agent exists in registry by ID
    */
-  hasAgent(name) {
+  hasAgent(agentId) {
     const registry = this.getRegistry();
-    return name in registry.agents;
+    return agentId in registry.agents;
   }
   /**
    * Get available agents with their metadata from registry
@@ -95,27 +103,59 @@ class LocalAgentRegistry {
     const registry = this.getRegistry();
     return registry.agents;
   }
+  /**
+   * Validate custom agent ID doesn't conflict with bundled registry
+   * @throws RegistryError if ID conflicts with builtin agent
+   */
+  validateCustomAgentId(agentId) {
+    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)
+      );
+    }
+    try {
+      const jsonData = (0, import_fs.readFileSync)(jsonPath, "utf-8");
+      const bundledRegistry = import_types.RegistrySchema.parse(
+        (0, import_types.normalizeRegistryJson)(JSON.parse(jsonData))
+      );
+      if (agentId in bundledRegistry.agents) {
+        throw import_errors.RegistryError.customAgentNameConflict(agentId);
+      }
+    } catch (error) {
+      if (error instanceof Error && /name conflicts with builtin agent/.test(error.message)) {
+        throw error;
+      }
+      throw import_errors.RegistryError.registryParseError(
+        jsonPath,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
   /**
    * Resolve main config file for installed agent
    * Handles both directory agents (with main field) and single-file agents
    */
-  resolveMainConfig(agentDir, agentName) {
+  resolveMainConfig(agentDir, agentId) {
     const registry = this.getRegistry();
-    const agentData = registry.agents[agentName];
+    const agentData = registry.agents[agentId];
     if (!agentData) {
       const available = Object.keys(registry.agents);
-      throw import_errors.RegistryError.agentNotFound(agentName, available);
+      throw import_errors.RegistryError.agentNotFound(agentId, available);
     }
     if (agentData.source.endsWith("/")) {
       if (!agentData.main) {
         throw import_errors.RegistryError.agentInvalidEntry(
-          agentName,
+          agentId,
           "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);
+        throw import_errors.RegistryError.mainConfigMissing(agentId, mainConfigPath);
       }
       return mainConfigPath;
     } else {
@@ -129,22 +169,29 @@ class LocalAgentRegistry {
   }
   /**
    * Install agent atomically using temp + rename pattern
-   * @param agentName Name of the agent to install
+   * @param agentId ID 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}`);
+  async installAgent(agentId, injectPreferences = true) {
+    import_logger.logger.info(`Installing agent: ${agentId}`);
     const registry = this.getRegistry();
-    const agentData = registry.agents[agentName];
+    const agentData = registry.agents[agentId];
     if (!agentData) {
       const available = Object.keys(registry.agents);
-      throw import_errors.RegistryError.agentNotFound(agentName, available);
+      throw import_errors.RegistryError.agentNotFound(agentId, available);
     }
     const globalAgentsDir = (0, import_path2.getDextoGlobalPath)("agents");
-    const targetDir = import_path.default.join(globalAgentsDir, agentName);
+    const targetDir = import_path.default.resolve(globalAgentsDir, agentId);
+    const relTarget = import_path.default.relative(globalAgentsDir, targetDir);
+    if (relTarget.startsWith("..") || import_path.default.isAbsolute(relTarget)) {
+      throw import_errors.RegistryError.installationFailed(
+        agentId,
+        "invalid agentId: path traversal detected"
+      );
+    }
     if ((0, import_fs.existsSync)(targetDir)) {
-      import_logger.logger.info(`Agent '${agentName}' already installed`);
-      return this.resolveMainConfig(targetDir, agentName);
+      import_logger.logger.info(`Agent '${agentId}' already installed`);
+      return this.resolveMainConfig(targetDir, agentId);
     }
     await import_fs2.promises.mkdir(globalAgentsDir, { recursive: true });
     const sourcePath = (0, import_path2.resolveBundledScript)(`agents/${agentData.source}`);
@@ -157,31 +204,144 @@ class LocalAgentRegistry {
         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);
+      const mainConfigPath = this.resolveMainConfig(tempDir, agentId);
       if (!(0, import_fs.existsSync)(mainConfigPath)) {
-        throw import_errors.RegistryError.installationValidationFailed(agentName, mainConfigPath);
+        throw import_errors.RegistryError.installationValidationFailed(agentId, mainConfigPath);
       }
       await import_fs2.promises.rename(tempDir, targetDir);
-      import_logger.logger.info(`\u2713 Installed agent '${agentName}' to ${targetDir}`);
+      import_logger.logger.info(`\u2713 Installed agent '${agentId}' 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}'`);
+          import_logger.logger.info(`\u2713 Applied global preferences to installed agent '${agentId}'`);
         } catch (error) {
           import_logger.logger.warn(
-            `Failed to inject preferences to '${agentName}': ${error instanceof Error ? error.message : String(error)}`
+            `Failed to inject preferences to '${agentId}': ${error instanceof Error ? error.message : String(error)}`
           );
           console.log(
-            `\u26A0\uFE0F  Warning: Could not apply preferences to '${agentName}' - agent will use bundled settings`
+            `\u26A0\uFE0F  Warning: Could not apply preferences to '${agentId}' - agent will use bundled settings`
           );
         }
       } else {
         import_logger.logger.info(
-          `Skipped preference injection for '${agentName}' (injectPreferences=false)`
+          `Skipped preference injection for '${agentId}' (injectPreferences=false)`
+        );
+      }
+      return this.resolveMainConfig(targetDir, agentId);
+    } 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 instanceof Error ? cleanupError.message : String(cleanupError)}. Skipping cleanup...`
         );
       }
-      return this.resolveMainConfig(targetDir, agentName);
+      throw import_errors.RegistryError.installationFailed(
+        agentId,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Install a custom agent from a local file path
+   * @param agentId Unique identifier for the custom agent
+   * @param sourcePath Absolute path to agent YAML file or directory
+   * @param metadata Agent metadata (name for display, description, author, tags, main)
+   * @param injectPreferences Whether to inject global preferences (default: true)
+   * @returns Path to the installed agent's main config file
+   */
+  async installCustomAgentFromPath(agentId, sourcePath, metadata, injectPreferences = true) {
+    import_logger.logger.info(`Installing custom agent '${agentId}' from ${sourcePath}`);
+    this.validateCustomAgentId(agentId);
+    if (!(0, import_fs.existsSync)(sourcePath)) {
+      throw import_errors.RegistryError.configNotFound(sourcePath);
+    }
+    const globalAgentsDir = (0, import_path2.getDextoGlobalPath)("agents");
+    const targetDir = import_path.default.resolve(globalAgentsDir, agentId);
+    const relTarget = import_path.default.relative(globalAgentsDir, targetDir);
+    if (relTarget.startsWith("..") || import_path.default.isAbsolute(relTarget)) {
+      throw import_errors.RegistryError.installationFailed(
+        agentId,
+        "invalid agentId: path traversal detected"
+      );
+    }
+    if ((0, import_fs.existsSync)(targetDir)) {
+      throw import_errors.RegistryError.agentAlreadyExists(agentId);
+    }
+    await import_fs2.promises.mkdir(globalAgentsDir, { recursive: true });
+    const stats = await import_fs2.promises.stat(sourcePath);
+    const isDirectory = stats.isDirectory();
+    const configFileName = isDirectory ? void 0 : `${agentId}.yml`;
+    if (!metadata.description) {
+      throw import_errors.RegistryError.installationFailed(agentId, "description is required");
+    }
+    if (isDirectory && !metadata.main) {
+      throw import_errors.RegistryError.installationFailed(
+        agentId,
+        "main field is required for directory-based agents"
+      );
+    }
+    const displayName = metadata.name || agentId.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+    const registryEntry = {
+      id: agentId,
+      name: displayName,
+      description: metadata.description,
+      author: metadata.author,
+      tags: metadata.tags,
+      source: isDirectory ? `${agentId}/` : configFileName,
+      main: metadata.main
+    };
+    const tempDir = `${targetDir}.tmp.${Date.now()}`;
+    try {
+      if (isDirectory) {
+        await (0, import_path2.copyDirectory)(sourcePath, tempDir);
+      } else {
+        await import_fs2.promises.mkdir(tempDir, { recursive: true });
+        const targetFile = import_path.default.join(tempDir, configFileName);
+        await import_fs2.promises.copyFile(sourcePath, targetFile);
+      }
+      const tempMainConfigPath = isDirectory ? import_path.default.join(tempDir, metadata.main) : import_path.default.join(tempDir, configFileName);
+      if (!(0, import_fs.existsSync)(tempMainConfigPath)) {
+        throw import_errors.RegistryError.installationValidationFailed(agentId, tempMainConfigPath);
+      }
+      await import_fs2.promises.rename(tempDir, targetDir);
+      import_logger.logger.info(`\u2713 Installed custom agent '${agentId}' to ${targetDir}`);
+      const mainConfigPath = isDirectory && metadata.main ? import_path.default.join(targetDir, metadata.main) : import_path.default.join(targetDir, configFileName);
+      try {
+        await (0, import_user_registry.addAgentToUserRegistry)(agentId, registryEntry);
+        import_logger.logger.info(`\u2713 Added '${agentId}' to user registry`);
+        this._registry = null;
+      } catch (registryError) {
+        try {
+          if ((0, import_fs.existsSync)(targetDir)) {
+            await import_fs2.promises.rm(targetDir, { recursive: true, force: true });
+            import_logger.logger.info(`Rolled back installation: removed ${targetDir}`);
+          }
+        } catch (rollbackError) {
+          import_logger.logger.error(
+            `Rollback failed for '${agentId}': ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`
+          );
+        }
+        throw registryError;
+      }
+      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 custom agent '${agentId}'`);
+        } catch (error) {
+          import_logger.logger.warn(
+            `Failed to inject preferences to '${agentId}': ${error instanceof Error ? error.message : String(error)}`
+          );
+          console.log(
+            `\u26A0\uFE0F  Warning: Could not apply preferences to '${agentId}' - agent will use default settings`
+          );
+        }
+      }
+      return mainConfigPath;
     } catch (error) {
       try {
         if ((0, import_fs.existsSync)(tempDir)) {
@@ -189,46 +349,50 @@ class LocalAgentRegistry {
         }
       } catch (cleanupError) {
         import_logger.logger.error(
-          `Failed to clean up temp directory: ${cleanupError}. Skipping cleanup...`
+          `Failed to clean up temp directory: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}. Skipping cleanup...`
         );
       }
       throw import_errors.RegistryError.installationFailed(
-        agentName,
+        agentId,
         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)
+   * Resolve a registry agent ID to a config path
+   * NOTE: Only handles registry IDs, not file paths (routing done in loadAgentConfig)
    * Handles installing agent if needed
-   * @param agentName Name of the agent to resolve
+   * @param agentId ID 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}`);
+  async resolveAgent(agentId, autoInstall = true, injectPreferences = true) {
+    import_logger.logger.debug(`Resolving registry agent: ${agentId}`);
     const globalAgentsDir = (0, import_path2.getDextoGlobalPath)("agents");
-    const installedPath = import_path.default.join(globalAgentsDir, agentName);
+    const installedPath = import_path.default.resolve(globalAgentsDir, agentId);
+    const relInstalled = import_path.default.relative(globalAgentsDir, installedPath);
+    if (relInstalled.startsWith("..") || import_path.default.isAbsolute(relInstalled)) {
+      throw import_errors.RegistryError.agentNotFound(agentId, Object.keys(this.getRegistry().agents));
+    }
     if ((0, import_fs.existsSync)(installedPath)) {
-      const mainConfig = this.resolveMainConfig(installedPath, agentName);
-      import_logger.logger.debug(`Resolved installed agent '${agentName}' to: ${mainConfig}`);
+      const mainConfig = this.resolveMainConfig(installedPath, agentId);
+      import_logger.logger.debug(`Resolved installed agent '${agentId}' to: ${mainConfig}`);
       return mainConfig;
     }
-    import_logger.logger.debug(`Agent '${agentName}' not found in installed path: ${installedPath}`);
-    if (this.hasAgent(agentName)) {
+    import_logger.logger.debug(`Agent '${agentId}' not found in installed path: ${installedPath}`);
+    if (this.hasAgent(agentId)) {
       if (autoInstall) {
-        import_logger.logger.info(`Installing agent '${agentName}' from registry...`);
-        return await this.installAgent(agentName, injectPreferences);
+        import_logger.logger.info(`Installing agent '${agentId}' from registry...`);
+        return await this.installAgent(agentId, injectPreferences);
       } else {
         const registry2 = this.getRegistry();
         const available2 = Object.keys(registry2.agents);
-        throw import_errors.RegistryError.agentNotInstalledAutoInstallDisabled(agentName, available2);
+        throw import_errors.RegistryError.agentNotInstalledAutoInstallDisabled(agentId, available2);
       }
     }
     const registry = this.getRegistry();
     const available = Object.keys(registry.agents);
-    throw import_errors.RegistryError.agentNotFound(agentName, available);
+    throw import_errors.RegistryError.agentNotFound(agentId, available);
   }
   /**
    * Get list of currently installed agents
@@ -247,32 +411,56 @@ class LocalAgentRegistry {
     }
   }
   /**
-   * Check if an agent is safe to uninstall (not the default-agent which is critical)
+   * Check if an agent is safe to uninstall (not the default agent from preferences)
    */
-  isAgentSafeToUninstall(agentName) {
-    return agentName !== "default-agent";
+  async isAgentSafeToUninstall(agentId) {
+    try {
+      const preferences = await (0, import_loader.loadGlobalPreferences)();
+      const defaultAgent = preferences.defaults.defaultAgent;
+      return agentId !== defaultAgent;
+    } catch {
+      import_logger.logger.warn("Could not load preferences, using fallback protection for default-agent");
+      return agentId !== "default-agent";
+    }
   }
   /**
    * Uninstall an agent by removing its directory
-   * @param agentName Name of the agent to uninstall
+   * For custom agents: also removes from user registry
+   * For builtin agents: only removes from disk
+   * @param agentId ID of the agent to uninstall
    * @param force Whether to force uninstall even if agent is protected (default: false)
    */
-  async uninstallAgent(agentName, force = false) {
+  async uninstallAgent(agentId, 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}`);
+    const agentDir = import_path.default.resolve(globalAgentsDir, agentId);
+    const relAgent = import_path.default.relative(globalAgentsDir, agentDir);
+    if (relAgent.startsWith("..") || import_path.default.isAbsolute(relAgent)) {
+      throw import_errors.RegistryError.uninstallationFailed(
+        agentId,
+        "invalid agentId: path traversal detected"
+      );
+    }
+    import_logger.logger.info(`Uninstalling agent: ${agentId} from ${agentDir}`);
     if (!(0, import_fs.existsSync)(agentDir)) {
-      throw import_errors.RegistryError.agentNotInstalled(agentName);
+      throw import_errors.RegistryError.agentNotInstalled(agentId);
     }
-    if (!force && !this.isAgentSafeToUninstall(agentName)) {
-      throw import_errors.RegistryError.agentProtected(agentName);
+    if (!force && !await this.isAgentSafeToUninstall(agentId)) {
+      throw import_errors.RegistryError.agentProtected(agentId);
     }
+    const registry = this.getRegistry();
+    const agentData = registry.agents[agentId];
+    const isCustomAgent = agentData?.type === "custom";
     try {
       await import_fs2.promises.rm(agentDir, { recursive: true, force: true });
-      import_logger.logger.info(`\u2713 Removed agent '${agentName}' from ${agentDir}`);
+      import_logger.logger.info(`\u2713 Removed agent '${agentId}' from ${agentDir}`);
+      if (isCustomAgent) {
+        await (0, import_user_registry.removeAgentFromUserRegistry)(agentId);
+        import_logger.logger.info(`\u2713 Removed custom agent '${agentId}' from user registry`);
+        this._registry = null;
+      }
     } catch (error) {
       throw import_errors.RegistryError.uninstallationFailed(
-        agentName,
+        agentId,
         error instanceof Error ? error.message : String(error)
       );
     }