@dexto/agent-management 1.2.5

package/dist/registry/registry.js

@@ -0,0 +1,452 @@
+import { existsSync, readFileSync } from "fs";
+import { promises as fs } from "fs";
+import path from "path";
+import { logger } from "@dexto/core";
+import { resolveBundledScript, getDextoGlobalPath, copyDirectory } from "../utils/path.js";
+import { loadGlobalPreferences } from "../preferences/loader.js";
+import { writePreferencesToAgent } from "../writer.js";
+import {
+  RegistrySchema,
+  normalizeRegistryJson
+} from "./types.js";
+import { RegistryError } from "./errors.js";
+import {
+  loadUserRegistry,
+  mergeRegistries,
+  removeAgentFromUserRegistry,
+  addAgentToUserRegistry
+} from "./user-registry.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 and merge bundled + user registries
+   * 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");
+    }
+    let bundledRegistry;
+    try {
+      const jsonData = readFileSync(jsonPath, "utf-8");
+      const rawRegistry = JSON.parse(jsonData);
+      bundledRegistry = RegistrySchema.parse(normalizeRegistryJson(rawRegistry));
+    } catch (error) {
+      throw RegistryError.registryParseError(
+        jsonPath,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    const userRegistry = loadUserRegistry();
+    const merged = mergeRegistries(bundledRegistry, userRegistry);
+    logger.debug(
+      `Loaded registry: ${Object.keys(bundledRegistry.agents).length} bundled, ${Object.keys(userRegistry.agents).length} custom`
+    );
+    return merged;
+  }
+  /**
+   * Check if agent exists in registry by ID
+   */
+  hasAgent(agentId) {
+    const registry = this.getRegistry();
+    return agentId in registry.agents;
+  }
+  /**
+   * Get available agents with their metadata from registry
+   */
+  getAvailableAgents() {
+    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 = resolveBundledScript("agents/agent-registry.json");
+    } catch (error) {
+      throw RegistryError.registryNotFound(
+        "agents/agent-registry.json",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    try {
+      const jsonData = readFileSync(jsonPath, "utf-8");
+      const bundledRegistry = RegistrySchema.parse(
+        normalizeRegistryJson(JSON.parse(jsonData))
+      );
+      if (agentId in bundledRegistry.agents) {
+        throw RegistryError.customAgentNameConflict(agentId);
+      }
+    } catch (error) {
+      if (error instanceof Error && /name conflicts with builtin agent/.test(error.message)) {
+        throw error;
+      }
+      throw 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, agentId) {
+    const registry = this.getRegistry();
+    const agentData = registry.agents[agentId];
+    if (!agentData) {
+      const available = Object.keys(registry.agents);
+      throw RegistryError.agentNotFound(agentId, available);
+    }
+    if (agentData.source.endsWith("/")) {
+      if (!agentData.main) {
+        throw RegistryError.agentInvalidEntry(
+          agentId,
+          "directory entry missing main field"
+        );
+      }
+      const mainConfigPath = path.join(agentDir, agentData.main);
+      if (!existsSync(mainConfigPath)) {
+        throw RegistryError.mainConfigMissing(agentId, 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 agentId ID of the agent to install
+   * @param injectPreferences Whether to inject global preferences into installed agent (default: true)
+   */
+  async installAgent(agentId, injectPreferences = true) {
+    logger.info(`Installing agent: ${agentId}`);
+    const registry = this.getRegistry();
+    const agentData = registry.agents[agentId];
+    if (!agentData) {
+      const available = Object.keys(registry.agents);
+      throw RegistryError.agentNotFound(agentId, available);
+    }
+    const globalAgentsDir = getDextoGlobalPath("agents");
+    const targetDir = path.resolve(globalAgentsDir, agentId);
+    const relTarget = path.relative(globalAgentsDir, targetDir);
+    if (relTarget.startsWith("..") || path.isAbsolute(relTarget)) {
+      throw RegistryError.installationFailed(
+        agentId,
+        "invalid agentId: path traversal detected"
+      );
+    }
+    if (existsSync(targetDir)) {
+      logger.info(`Agent '${agentId}' already installed`);
+      return this.resolveMainConfig(targetDir, agentId);
+    }
+    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, agentId);
+      if (!existsSync(mainConfigPath)) {
+        throw RegistryError.installationValidationFailed(agentId, mainConfigPath);
+      }
+      await fs.rename(tempDir, targetDir);
+      logger.info(`\u2713 Installed agent '${agentId}' to ${targetDir}`);
+      if (injectPreferences) {
+        try {
+          const preferences = await loadGlobalPreferences();
+          await writePreferencesToAgent(targetDir, preferences);
+          logger.info(`\u2713 Applied global preferences to installed agent '${agentId}'`);
+        } catch (error) {
+          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 bundled settings`
+          );
+        }
+      } else {
+        logger.info(
+          `Skipped preference injection for '${agentId}' (injectPreferences=false)`
+        );
+      }
+      return this.resolveMainConfig(targetDir, agentId);
+    } 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 instanceof Error ? cleanupError.message : String(cleanupError)}. Skipping cleanup...`
+        );
+      }
+      throw 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) {
+    logger.info(`Installing custom agent '${agentId}' from ${sourcePath}`);
+    this.validateCustomAgentId(agentId);
+    if (!existsSync(sourcePath)) {
+      throw RegistryError.configNotFound(sourcePath);
+    }
+    const globalAgentsDir = getDextoGlobalPath("agents");
+    const targetDir = path.resolve(globalAgentsDir, agentId);
+    const relTarget = path.relative(globalAgentsDir, targetDir);
+    if (relTarget.startsWith("..") || path.isAbsolute(relTarget)) {
+      throw RegistryError.installationFailed(
+        agentId,
+        "invalid agentId: path traversal detected"
+      );
+    }
+    if (existsSync(targetDir)) {
+      throw RegistryError.agentAlreadyExists(agentId);
+    }
+    await fs.mkdir(globalAgentsDir, { recursive: true });
+    const stats = await fs.stat(sourcePath);
+    const isDirectory = stats.isDirectory();
+    const configFileName = isDirectory ? void 0 : `${agentId}.yml`;
+    if (!metadata.description) {
+      throw RegistryError.installationFailed(agentId, "description is required");
+    }
+    if (isDirectory && !metadata.main) {
+      throw 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 copyDirectory(sourcePath, tempDir);
+      } else {
+        await fs.mkdir(tempDir, { recursive: true });
+        const targetFile = path.join(tempDir, configFileName);
+        await fs.copyFile(sourcePath, targetFile);
+      }
+      const tempMainConfigPath = isDirectory ? path.join(tempDir, metadata.main) : path.join(tempDir, configFileName);
+      if (!existsSync(tempMainConfigPath)) {
+        throw RegistryError.installationValidationFailed(agentId, tempMainConfigPath);
+      }
+      await fs.rename(tempDir, targetDir);
+      logger.info(`\u2713 Installed custom agent '${agentId}' to ${targetDir}`);
+      const mainConfigPath = isDirectory && metadata.main ? path.join(targetDir, metadata.main) : path.join(targetDir, configFileName);
+      try {
+        await addAgentToUserRegistry(agentId, registryEntry);
+        logger.info(`\u2713 Added '${agentId}' to user registry`);
+        this._registry = null;
+      } catch (registryError) {
+        try {
+          if (existsSync(targetDir)) {
+            await fs.rm(targetDir, { recursive: true, force: true });
+            logger.info(`Rolled back installation: removed ${targetDir}`);
+          }
+        } catch (rollbackError) {
+          logger.error(
+            `Rollback failed for '${agentId}': ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`
+          );
+        }
+        throw registryError;
+      }
+      if (injectPreferences) {
+        try {
+          const preferences = await loadGlobalPreferences();
+          await writePreferencesToAgent(targetDir, preferences);
+          logger.info(`\u2713 Applied global preferences to custom agent '${agentId}'`);
+        } catch (error) {
+          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 (existsSync(tempDir)) {
+          await fs.rm(tempDir, { recursive: true, force: true });
+        }
+      } catch (cleanupError) {
+        logger.error(
+          `Failed to clean up temp directory: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}. Skipping cleanup...`
+        );
+      }
+      throw RegistryError.installationFailed(
+        agentId,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * 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 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(agentId, autoInstall = true, injectPreferences = true) {
+    logger.debug(`Resolving registry agent: ${agentId}`);
+    const globalAgentsDir = getDextoGlobalPath("agents");
+    const installedPath = path.resolve(globalAgentsDir, agentId);
+    const relInstalled = path.relative(globalAgentsDir, installedPath);
+    if (relInstalled.startsWith("..") || path.isAbsolute(relInstalled)) {
+      throw RegistryError.agentNotFound(agentId, Object.keys(this.getRegistry().agents));
+    }
+    if (existsSync(installedPath)) {
+      const mainConfig = this.resolveMainConfig(installedPath, agentId);
+      logger.debug(`Resolved installed agent '${agentId}' to: ${mainConfig}`);
+      return mainConfig;
+    }
+    logger.debug(`Agent '${agentId}' not found in installed path: ${installedPath}`);
+    if (this.hasAgent(agentId)) {
+      if (autoInstall) {
+        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 RegistryError.agentNotInstalledAutoInstallDisabled(agentId, available2);
+      }
+    }
+    const registry = this.getRegistry();
+    const available = Object.keys(registry.agents);
+    throw RegistryError.agentNotFound(agentId, 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 from preferences)
+   */
+  async isAgentSafeToUninstall(agentId) {
+    try {
+      const preferences = await loadGlobalPreferences();
+      const defaultAgent = preferences.defaults.defaultAgent;
+      return agentId !== defaultAgent;
+    } catch {
+      logger.warn("Could not load preferences, using fallback protection for default-agent");
+      return agentId !== "default-agent";
+    }
+  }
+  /**
+   * Uninstall an agent by removing its directory
+   * 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(agentId, force = false) {
+    const globalAgentsDir = getDextoGlobalPath("agents");
+    const agentDir = path.resolve(globalAgentsDir, agentId);
+    const relAgent = path.relative(globalAgentsDir, agentDir);
+    if (relAgent.startsWith("..") || path.isAbsolute(relAgent)) {
+      throw RegistryError.uninstallationFailed(
+        agentId,
+        "invalid agentId: path traversal detected"
+      );
+    }
+    logger.info(`Uninstalling agent: ${agentId} from ${agentDir}`);
+    if (!existsSync(agentDir)) {
+      throw RegistryError.agentNotInstalled(agentId);
+    }
+    if (!force && !await this.isAgentSafeToUninstall(agentId)) {
+      throw RegistryError.agentProtected(agentId);
+    }
+    const registry = this.getRegistry();
+    const agentData = registry.agents[agentId];
+    const isCustomAgent = agentData?.type === "custom";
+    try {
+      await fs.rm(agentDir, { recursive: true, force: true });
+      logger.info(`\u2713 Removed agent '${agentId}' from ${agentDir}`);
+      if (isCustomAgent) {
+        await removeAgentFromUserRegistry(agentId);
+        logger.info(`\u2713 Removed custom agent '${agentId}' from user registry`);
+        this._registry = null;
+      }
+    } catch (error) {
+      throw RegistryError.uninstallationFailed(
+        agentId,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+}
+function getAgentRegistry() {
+  if (cachedRegistry === null) {
+    cachedRegistry = new LocalAgentRegistry();
+  }
+  return cachedRegistry;
+}
+export {
+  LocalAgentRegistry,
+  getAgentRegistry
+};

package/dist/registry/types.cjs

@@ -0,0 +1,74 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+__export(types_exports, {
+  AgentRegistryEntrySchema: () => AgentRegistryEntrySchema,
+  RegistrySchema: () => RegistrySchema,
+  deriveDisplayName: () => deriveDisplayName,
+  normalizeRegistryJson: () => normalizeRegistryJson
+});
+module.exports = __toCommonJS(types_exports);
+var import_zod = require("zod");
+function deriveDisplayName(slug) {
+  return slug.split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+const AgentRegistryEntrySchema = import_zod.z.object({
+  id: import_zod.z.string().describe("Unique identifier for the agent"),
+  name: import_zod.z.string().describe("Display name for the agent"),
+  description: import_zod.z.string(),
+  author: import_zod.z.string(),
+  tags: import_zod.z.array(import_zod.z.string()),
+  source: import_zod.z.string(),
+  main: import_zod.z.string().optional(),
+  type: import_zod.z.enum(["builtin", "custom"]).default("builtin").describe("Agent type")
+}).strict();
+const RegistrySchema = import_zod.z.object({
+  version: import_zod.z.string(),
+  agents: import_zod.z.record(import_zod.z.string(), AgentRegistryEntrySchema)
+}).strict();
+function normalizeRegistryJson(raw) {
+  if (!raw || typeof raw !== "object") {
+    return { version: "1.0.0", agents: {} };
+  }
+  const input = raw;
+  const normalizedAgents = {};
+  const agents = input.agents && typeof input.agents === "object" && input.agents !== null ? input.agents : {};
+  for (const [agentId, value] of Object.entries(agents)) {
+    if (!value || typeof value !== "object") continue;
+    const entry = { ...value };
+    if (!entry.id || typeof entry.id !== "string" || entry.id.trim() !== agentId) {
+      entry.id = agentId;
+    }
+    if (!entry.name || typeof entry.name !== "string" || !entry.name.trim()) {
+      entry.name = deriveDisplayName(agentId);
+    }
+    normalizedAgents[agentId] = entry;
+  }
+  return {
+    version: typeof input.version === "string" && input.version.trim().length > 0 ? input.version : "1.0.0",
+    agents: normalizedAgents
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentRegistryEntrySchema,
+  RegistrySchema,
+  deriveDisplayName,
+  normalizeRegistryJson
+});

package/dist/registry/types.d.ts

@@ -0,0 +1,142 @@
+import { z } from 'zod';
+export declare function deriveDisplayName(slug: string): string;
+/**
+ * Schema for agent data in registry JSON
+ */
+export declare const AgentRegistryEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    author: z.ZodString;
+    tags: z.ZodArray<z.ZodString, "many">;
+    source: z.ZodString;
+    main: z.ZodOptional<z.ZodString>;
+    type: z.ZodDefault<z.ZodEnum<["builtin", "custom"]>>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    type: "custom" | "builtin";
+    id: string;
+    description: string;
+    author: string;
+    tags: string[];
+    source: string;
+    main?: string | undefined;
+}, {
+    name: string;
+    id: string;
+    description: string;
+    author: string;
+    tags: string[];
+    source: string;
+    type?: "custom" | "builtin" | undefined;
+    main?: string | undefined;
+}>;
+export type AgentRegistryEntry = z.output<typeof AgentRegistryEntrySchema>;
+/**
+ * Schema for complete registry JSON
+ */
+export declare const RegistrySchema: z.ZodObject<{
+    version: z.ZodString;
+    agents: z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        author: z.ZodString;
+        tags: z.ZodArray<z.ZodString, "many">;
+        source: z.ZodString;
+        main: z.ZodOptional<z.ZodString>;
+        type: z.ZodDefault<z.ZodEnum<["builtin", "custom"]>>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        type: "custom" | "builtin";
+        id: string;
+        description: string;
+        author: string;
+        tags: string[];
+        source: string;
+        main?: string | undefined;
+    }, {
+        name: string;
+        id: string;
+        description: string;
+        author: string;
+        tags: string[];
+        source: string;
+        type?: "custom" | "builtin" | undefined;
+        main?: string | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    version: string;
+    agents: Record<string, {
+        name: string;
+        type: "custom" | "builtin";
+        id: string;
+        description: string;
+        author: string;
+        tags: string[];
+        source: string;
+        main?: string | undefined;
+    }>;
+}, {
+    version: string;
+    agents: Record<string, {
+        name: string;
+        id: string;
+        description: string;
+        author: string;
+        tags: string[];
+        source: string;
+        type?: "custom" | "builtin" | undefined;
+        main?: string | undefined;
+    }>;
+}>;
+export type Registry = z.output<typeof RegistrySchema>;
+type RawRegistry = {
+    version?: unknown;
+    agents?: Record<string, unknown> | unknown;
+};
+/**
+ * Normalize registry JSON data to ensure consistency.
+ * Validates that id field matches the registry key and derives display names if missing.
+ */
+export declare function normalizeRegistryJson(raw: unknown): RawRegistry;
+/**
+ * Agent registry interface
+ */
+export interface AgentRegistry {
+    /**
+     * Returns true if the registry contains an agent with the provided ID
+     */
+    hasAgent(agentId: string): boolean;
+    /**
+     * Returns a map of available agent IDs to their registry entries
+     */
+    getAvailableAgents(): Record<string, AgentRegistryEntry>;
+    /**
+     * Installs an agent from the registry by ID
+     * @param agentId - Unique agent identifier
+     * @param injectPreferences - Whether to inject global preferences (default: true)
+     * @returns Path to the installed agent config
+     */
+    installAgent(agentId: string, injectPreferences?: boolean): Promise<string>;
+    /**
+     * Uninstalls an agent by ID
+     * @param agentId - Unique agent identifier
+     * @param force - Whether to force uninstall protected agents (default: false)
+     */
+    uninstallAgent(agentId: string, force?: boolean): Promise<void>;
+    /**
+     * Returns list of currently installed agent IDs
+     */
+    getInstalledAgents(): Promise<string[]>;
+    /**
+     * Resolves an agent ID or path and optionally auto-installs if needed
+     * @param idOrPath - Agent ID from registry or filesystem path
+     * @param autoInstall - Whether to auto-install from registry (default: true)
+     * @param injectPreferences - Whether to inject preferences during install (default: true)
+     * @returns Path to the agent config file
+     */
+    resolveAgent(idOrPath: string, autoInstall?: boolean, injectPreferences?: boolean): Promise<string>;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/registry/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/registry/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMtD;AAED;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWxB,CAAC;AAEd,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE3E;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKd,CAAC;AAEd,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CAAC;AAEvD,KAAK,WAAW,GAAG;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;CAC9C,CAAC;AAEF;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW,CAsC/D;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC1B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IACnC;;OAEG;IACH,kBAAkB,IAAI,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IACzD;;;;;OAKG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5E;;;;OAIG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChE;;OAEG;IACH,kBAAkB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACxC;;;;;;OAMG;IACH,YAAY,CACR,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,OAAO,EACrB,iBAAiB,CAAC,EAAE,OAAO,GAC5B,OAAO,CAAC,MAAM,CAAC,CAAC;CACtB"}