@dexto/agent-management 1.2.5

package/dist/AgentOrchestrator.js

@@ -0,0 +1,239 @@
+import { logger, AgentError, DextoAgent, DextoValidationError } from "@dexto/core";
+import { loadAgentConfig, enrichAgentConfig } from "./config/index.js";
+import { getAgentRegistry } from "./registry/registry.js";
+import { deriveDisplayName } from "./registry/types.js";
+import { ZodError } from "zod";
+import { zodToIssues } from "@dexto/core";
+class AgentOrchestrator {
+  /**
+   * Lists available and installed agents from the registry.
+   * Returns a structured object containing both installed and available agents,
+   * along with metadata like descriptions, authors, and tags.
+   *
+   * @returns Promise resolving to object with installed and available agent lists
+   *
+   * @example
+   * ```typescript
+   * const agents = await AgentOrchestrator.listAgents();
+   * console.log(agents.installed); // ['default', 'my-custom-agent']
+   * console.log(agents.available); // [{ name: 'productivity', description: '...', ... }]
+   * console.log(agents.current?.name); // 'default'
+   * ```
+   */
+  static async listAgents() {
+    const agentRegistry = getAgentRegistry();
+    const availableMap = agentRegistry.getAvailableAgents();
+    const installedNames = await agentRegistry.getInstalledAgents();
+    const installed = await Promise.all(
+      installedNames.map(async (agentId) => {
+        const registryEntry = availableMap[agentId];
+        if (registryEntry) {
+          return {
+            id: agentId,
+            name: registryEntry.name,
+            description: registryEntry.description,
+            author: registryEntry.author,
+            tags: registryEntry.tags,
+            type: registryEntry.type
+          };
+        } else {
+          try {
+            const config = await loadAgentConfig(agentId);
+            const author = config.agentCard?.provider?.organization;
+            const result = {
+              id: agentId,
+              name: typeof config.agentCard?.name === "string" ? config.agentCard.name : deriveDisplayName(agentId),
+              description: config.agentCard?.description || "Local agent",
+              tags: [],
+              type: "custom"
+              // Assume custom if not in registry
+            };
+            if (author) {
+              result.author = author;
+            }
+            return result;
+          } catch {
+            const result = {
+              id: agentId,
+              name: deriveDisplayName(agentId),
+              description: "Local agent (config unavailable)",
+              tags: [],
+              type: "custom"
+              // Assume custom if not in registry
+            };
+            return result;
+          }
+        }
+      })
+    );
+    const available = Object.entries(availableMap).filter(([agentId]) => !installedNames.includes(agentId)).map(([agentId, entry]) => ({
+      id: agentId,
+      name: entry.name,
+      description: entry.description,
+      author: entry.author,
+      tags: entry.tags,
+      type: entry.type
+    }));
+    return {
+      installed,
+      available,
+      current: { id: null, name: null }
+      // TODO: Track current agent name
+    };
+  }
+  /**
+   * Installs an agent from the registry.
+   * Downloads and sets up the specified agent, making it available for use.
+   *
+   * @param agentName The name of the agent to install from the registry
+   * @returns Promise that resolves when installation is complete
+   *
+   * @throws {AgentError} When agent is not found in registry or installation fails
+   *
+   * @example
+   * ```typescript
+   * await AgentOrchestrator.installAgent('productivity');
+   * console.log('Productivity agent installed successfully');
+   * ```
+   */
+  static async installAgent(agentName) {
+    const agentRegistry = getAgentRegistry();
+    if (!agentRegistry.hasAgent(agentName)) {
+      throw AgentError.apiValidationError(`Agent '${agentName}' not found in registry`);
+    }
+    try {
+      await agentRegistry.installAgent(agentName, true);
+      logger.info(`Successfully installed agent: ${agentName}`);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(`Failed to install agent ${agentName}: ${errorMessage}`);
+      throw AgentError.apiValidationError(
+        `Installation failed for agent '${agentName}'`,
+        error
+      );
+    }
+  }
+  /**
+   * Installs a custom agent from a local file or directory path.
+   * Creates a new custom agent entry in the user registry with provided metadata.
+   *
+   * @param agentName The name to use for the custom agent (must be unique)
+   * @param sourcePath Absolute path to the agent YAML file or directory
+   * @param metadata Agent metadata (description, author, tags, main config file)
+   * @param injectPreferences Whether to inject global preferences into agent config (default: true)
+   * @returns Promise resolving to the path of the installed main config file
+   *
+   * @throws {AgentError} When name conflicts with existing agent or installation fails
+   *
+   * @example
+   * ```typescript
+   * await AgentOrchestrator.installCustomAgent('my-coding-agent', '/path/to/agent.yml', {
+   *   description: 'Custom coding assistant',
+   *   author: 'John Doe',
+   *   tags: ['coding', 'custom']
+   * });
+   * console.log('Custom agent installed successfully');
+   * ```
+   */
+  static async installCustomAgent(agentName, sourcePath, metadata, injectPreferences = true) {
+    const agentRegistry = getAgentRegistry();
+    try {
+      const mainConfigPath = await agentRegistry.installCustomAgentFromPath(
+        agentName,
+        sourcePath,
+        metadata,
+        injectPreferences
+      );
+      logger.info(`Successfully installed custom agent: ${agentName}`);
+      return mainConfigPath;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(`Failed to install custom agent ${agentName}: ${errorMessage}`);
+      throw AgentError.apiValidationError(
+        `Installation failed for custom agent '${agentName}'`,
+        error
+      );
+    }
+  }
+  /**
+   * Uninstalls an agent by removing its directory from disk.
+   * For custom agents: also removes from user registry.
+   * For builtin agents: only removes from disk (can be reinstalled).
+   *
+   * @param agentName The name of the agent to uninstall
+   * @param force Whether to force uninstall even if agent is protected (default: false)
+   * @returns Promise that resolves when uninstallation is complete
+   *
+   * @throws {AgentError} When agent is not installed or uninstallation fails
+   *
+   * @example
+   * ```typescript
+   * await AgentOrchestrator.uninstallAgent('my-custom-agent');
+   * console.log('Agent uninstalled successfully');
+   * ```
+   */
+  static async uninstallAgent(agentName, force = false) {
+    const agentRegistry = getAgentRegistry();
+    try {
+      await agentRegistry.uninstallAgent(agentName, force);
+      logger.info(`Successfully uninstalled agent: ${agentName}`);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(`Failed to uninstall agent ${agentName}: ${errorMessage}`);
+      throw AgentError.apiValidationError(
+        `Uninstallation failed for agent '${agentName}'`,
+        error
+      );
+    }
+  }
+  /**
+   * Creates a new agent instance for the specified agent name.
+   * This method resolves the agent (installing if needed), loads its configuration,
+   * and returns a new DextoAgent instance ready to be started.
+   *
+   * This is a factory method that doesn't affect any existing agent instances.
+   * The caller is responsible for managing the lifecycle of the returned agent.
+   *
+   * @param agentName The name of the agent to create
+   * @returns Promise resolving to a new DextoAgent instance (not started)
+   *
+   * @throws {AgentError} When agent is not found or creation fails
+   *
+   * @example
+   * ```typescript
+   * const newAgent = await AgentOrchestrator.createAgent('productivity');
+   * await newAgent.start();
+   * ```
+   */
+  static async createAgent(agentName) {
+    const agentRegistry = getAgentRegistry();
+    try {
+      const agentPath = await agentRegistry.resolveAgent(agentName, true, true);
+      const config = await loadAgentConfig(agentPath);
+      const enrichedConfig = enrichAgentConfig(config, agentPath);
+      logger.info(`Creating agent: ${agentName}`);
+      const newAgent = new DextoAgent(enrichedConfig, agentPath);
+      logger.info(`Successfully created agent: ${agentName}`);
+      return newAgent;
+    } catch (error) {
+      if (error instanceof ZodError) {
+        const issues = zodToIssues(error, "error");
+        const formatted = issues.map((issue) => {
+          const path = Array.isArray(issue.path) ? issue.path.join(".") : String(issue.path);
+          return `${path}: ${issue.message}`;
+        });
+        const message = `Configuration validation failed for agent '${agentName}':
+${formatted.join("\n")}`;
+        logger.error(message);
+        throw new DextoValidationError(issues);
+      }
+      logger.error(
+        `Failed to create agent '${agentName}': ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw AgentError.apiValidationError(`Failed to create agent '${agentName}'`, error);
+    }
+  }
+}
+export {
+  AgentOrchestrator
+};

package/dist/config/config-enrichment.cjs

@@ -0,0 +1,117 @@
+"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 config_enrichment_exports = {};
+__export(config_enrichment_exports, {
+  deriveAgentId: () => deriveAgentId,
+  enrichAgentConfig: () => enrichAgentConfig
+});
+module.exports = __toCommonJS(config_enrichment_exports);
+var import_path = require("../utils/path.js");
+var path = __toESM(require("path"), 1);
+function deriveAgentId(config, configPath) {
+  if (config.agentCard?.name) {
+    const sanitizedName = config.agentCard.name.toLowerCase().replace(/[^a-z0-9-_]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+    if (sanitizedName) {
+      return sanitizedName;
+    }
+  }
+  if (configPath) {
+    const basename = path.basename(configPath, path.extname(configPath));
+    if (basename && basename !== "agent" && basename !== "config") {
+      return basename;
+    }
+  }
+  return "default-agent";
+}
+function enrichAgentConfig(config, configPath, isInteractiveCli = false) {
+  const agentId = deriveAgentId(config, configPath);
+  const logPath = (0, import_path.getDextoPath)("logs", `${agentId}.log`);
+  const dbPath = (0, import_path.getDextoPath)("database", `${agentId}.db`);
+  const blobPath = (0, import_path.getDextoPath)("blobs", agentId);
+  const enriched = {
+    ...config,
+    agentId
+    // Set agentId explicitly (single source of truth)
+  };
+  if (!config.logger) {
+    const transports = isInteractiveCli ? [
+      {
+        type: "file",
+        path: logPath,
+        maxSize: 10 * 1024 * 1024,
+        // 10MB
+        maxFiles: 5
+      }
+    ] : [
+      { type: "console", colorize: true },
+      {
+        type: "file",
+        path: logPath,
+        maxSize: 10 * 1024 * 1024,
+        // 10MB
+        maxFiles: 5
+      }
+    ];
+    enriched.logger = {
+      level: "info",
+      transports
+    };
+  } else {
+    enriched.logger = config.logger;
+  }
+  if (!config.storage) {
+    enriched.storage = {
+      cache: { type: "in-memory" },
+      database: { type: "sqlite", path: dbPath },
+      blob: { type: "local", storePath: blobPath }
+    };
+  } else {
+    enriched.storage = {
+      ...config.storage
+    };
+    if (config.storage.database?.type === "sqlite") {
+      enriched.storage.database = {
+        ...config.storage.database,
+        path: config.storage.database.path || dbPath
+      };
+    }
+    if (config.storage.blob?.type === "local") {
+      enriched.storage.blob = {
+        ...config.storage.blob,
+        storePath: config.storage.blob.storePath || blobPath
+      };
+    }
+  }
+  return enriched;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deriveAgentId,
+  enrichAgentConfig
+});

package/dist/config/config-enrichment.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Config Enrichment Layer
+ *
+ * Provides per-agent path defaults for file-based resources (logs, database, blobs, backups).
+ * This layer runs before agent initialization and injects explicit paths
+ * into the configuration, eliminating the need for core services to resolve paths themselves.
+ *
+ * Core services now require explicit paths - this enrichment layer provides them.
+ */
+import type { AgentConfig } from '@dexto/core';
+/**
+ * Derives an agent ID from config or file path for per-agent isolation.
+ * Priority: agentCard.name > filename (without extension) > 'default-agent'
+ */
+export declare function deriveAgentId(config: AgentConfig, configPath?: string): string;
+/**
+ * Enriches agent configuration with per-agent file paths.
+ * This function is called before creating the DextoAgent instance.
+ *
+ * Enrichment adds:
+ * - File transport to logger config (per-agent log file)
+ * - Full paths to storage config (SQLite database, blob storage)
+ * - Backup path to filesystem config (per-agent backups)
+ *
+ * @param config Agent configuration from YAML file + CLI overrides
+ * @param configPath Path to the agent config file (used for agent ID derivation)
+ * @param isInteractiveCli Whether this is interactive CLI mode (affects logger defaults) - defaults to false
+ * @returns Enriched configuration with explicit per-agent paths
+ */
+export declare function enrichAgentConfig(config: AgentConfig, configPath?: string, isInteractiveCli?: boolean): AgentConfig;
+//# sourceMappingURL=config-enrichment.d.ts.map

package/dist/config/config-enrichment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-enrichment.d.ts","sourceRoot":"","sources":["../../src/config/config-enrichment.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAyB9E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAC7B,MAAM,EAAE,WAAW,EACnB,UAAU,CAAC,EAAE,MAAM,EACnB,gBAAgB,GAAE,OAAe,GAClC,WAAW,CAkFb"}

package/dist/config/config-enrichment.js

@@ -0,0 +1,82 @@
+import { getDextoPath } from "../utils/path.js";
+import * as path from "path";
+function deriveAgentId(config, configPath) {
+  if (config.agentCard?.name) {
+    const sanitizedName = config.agentCard.name.toLowerCase().replace(/[^a-z0-9-_]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+    if (sanitizedName) {
+      return sanitizedName;
+    }
+  }
+  if (configPath) {
+    const basename = path.basename(configPath, path.extname(configPath));
+    if (basename && basename !== "agent" && basename !== "config") {
+      return basename;
+    }
+  }
+  return "default-agent";
+}
+function enrichAgentConfig(config, configPath, isInteractiveCli = false) {
+  const agentId = deriveAgentId(config, configPath);
+  const logPath = getDextoPath("logs", `${agentId}.log`);
+  const dbPath = getDextoPath("database", `${agentId}.db`);
+  const blobPath = getDextoPath("blobs", agentId);
+  const enriched = {
+    ...config,
+    agentId
+    // Set agentId explicitly (single source of truth)
+  };
+  if (!config.logger) {
+    const transports = isInteractiveCli ? [
+      {
+        type: "file",
+        path: logPath,
+        maxSize: 10 * 1024 * 1024,
+        // 10MB
+        maxFiles: 5
+      }
+    ] : [
+      { type: "console", colorize: true },
+      {
+        type: "file",
+        path: logPath,
+        maxSize: 10 * 1024 * 1024,
+        // 10MB
+        maxFiles: 5
+      }
+    ];
+    enriched.logger = {
+      level: "info",
+      transports
+    };
+  } else {
+    enriched.logger = config.logger;
+  }
+  if (!config.storage) {
+    enriched.storage = {
+      cache: { type: "in-memory" },
+      database: { type: "sqlite", path: dbPath },
+      blob: { type: "local", storePath: blobPath }
+    };
+  } else {
+    enriched.storage = {
+      ...config.storage
+    };
+    if (config.storage.database?.type === "sqlite") {
+      enriched.storage.database = {
+        ...config.storage.database,
+        path: config.storage.database.path || dbPath
+      };
+    }
+    if (config.storage.blob?.type === "local") {
+      enriched.storage.blob = {
+        ...config.storage.blob,
+        storePath: config.storage.blob.storePath || blobPath
+      };
+    }
+  }
+  return enriched;
+}
+export {
+  deriveAgentId,
+  enrichAgentConfig
+};

package/dist/config/config-manager.cjs

@@ -0,0 +1,57 @@
+"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 config_manager_exports = {};
+__export(config_manager_exports, {
+  reloadAgentConfigFromFile: () => reloadAgentConfigFromFile,
+  updateAgentConfigFile: () => updateAgentConfigFile
+});
+module.exports = __toCommonJS(config_manager_exports);
+var import_fs = require("fs");
+var import_yaml = require("yaml");
+var import_loader = require("./loader.js");
+var import_core = require("@dexto/core");
+var import_core2 = require("@dexto/core");
+var import_core3 = require("@dexto/core");
+async function updateAgentConfigFile(configPath, updates) {
+  const rawYaml = await import_fs.promises.readFile(configPath, "utf-8");
+  const doc = (0, import_yaml.parseDocument)(rawYaml);
+  const rawConfig = doc.toJSON();
+  const updatedRawConfig = { ...rawConfig, ...updates };
+  const parsed = import_core.AgentConfigSchema.safeParse(updatedRawConfig);
+  if (!parsed.success) {
+    const result = (0, import_core3.fail)((0, import_core3.zodToIssues)(parsed.error, "error"));
+    throw new import_core2.DextoValidationError(result.issues);
+  }
+  for (const [key, value] of Object.entries(updates)) {
+    doc.set(key, value);
+  }
+  const yamlContent = String(doc);
+  const tmpPath = `${configPath}.tmp`;
+  await import_fs.promises.writeFile(tmpPath, yamlContent, "utf-8");
+  await import_fs.promises.rename(tmpPath, configPath);
+  return parsed.data;
+}
+async function reloadAgentConfigFromFile(configPath) {
+  return await (0, import_loader.loadAgentConfig)(configPath);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  reloadAgentConfigFromFile,
+  updateAgentConfigFile
+});

package/dist/config/config-manager.d.ts

@@ -0,0 +1,51 @@
+import type { AgentConfig, ValidatedAgentConfig } from '@dexto/core';
+/**
+ * Updates an agent configuration file with partial updates.
+ * Reads raw YAML, merges updates, validates, and writes back atomically.
+ * Preserves comments, formatting, and environment variable placeholders.
+ *
+ * This is a CLI/server concern - handles file I/O for config updates.
+ * After calling this, you should call agent.reloadConfig() with the returned config.
+ *
+ * @param configPath Path to the agent configuration file
+ * @param updates Partial configuration updates to apply
+ * @returns The validated merged configuration
+ * @throws DextoValidationError if validation fails
+ * @throws Error if file operations fail
+ *
+ * @example
+ * ```typescript
+ * const newConfig = await updateAgentConfigFile('/path/to/agent.yml', {
+ *   mcpServers: {
+ *     ...currentConfig.mcpServers,
+ *     newServer: { command: 'mcp-server', type: 'stdio' }
+ *   }
+ * });
+ *
+ * const reloadResult = await agent.reloadConfig(newConfig);
+ * if (reloadResult.restartRequired.length > 0) {
+ *   await agent.restart();
+ * }
+ * ```
+ */
+export declare function updateAgentConfigFile(configPath: string, updates: Partial<AgentConfig>): Promise<ValidatedAgentConfig>;
+/**
+ * Reloads an agent configuration from disk.
+ * This is a CLI/server concern - handles file I/O for config loading.
+ * After calling this, you should call agent.reloadConfig() with the returned config.
+ *
+ * @param configPath Path to the agent configuration file
+ * @returns The loaded agent configuration
+ * @throws ConfigError if file cannot be read or parsed
+ *
+ * @example
+ * ```typescript
+ * const newConfig = await reloadAgentConfigFromFile('/path/to/agent.yml');
+ * const reloadResult = await agent.reloadConfig(newConfig);
+ * if (reloadResult.restartRequired.length > 0) {
+ *   await agent.restart();
+ * }
+ * ```
+ */
+export declare function reloadAgentConfigFromFile(configPath: string): Promise<AgentConfig>;
+//# sourceMappingURL=config-manager.d.ts.map

package/dist/config/config-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-manager.d.ts","sourceRoot":"","sources":["../../src/config/config-manager.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAKrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,qBAAqB,CACvC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,GAC9B,OAAO,CAAC,oBAAoB,CAAC,CAiC/B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAExF"}

package/dist/config/config-manager.js

@@ -0,0 +1,32 @@
+import { promises as fs } from "fs";
+import { parseDocument } from "yaml";
+import { loadAgentConfig } from "./loader.js";
+import { AgentConfigSchema } from "@dexto/core";
+import { DextoValidationError } from "@dexto/core";
+import { fail, zodToIssues } from "@dexto/core";
+async function updateAgentConfigFile(configPath, updates) {
+  const rawYaml = await fs.readFile(configPath, "utf-8");
+  const doc = parseDocument(rawYaml);
+  const rawConfig = doc.toJSON();
+  const updatedRawConfig = { ...rawConfig, ...updates };
+  const parsed = AgentConfigSchema.safeParse(updatedRawConfig);
+  if (!parsed.success) {
+    const result = fail(zodToIssues(parsed.error, "error"));
+    throw new DextoValidationError(result.issues);
+  }
+  for (const [key, value] of Object.entries(updates)) {
+    doc.set(key, value);
+  }
+  const yamlContent = String(doc);
+  const tmpPath = `${configPath}.tmp`;
+  await fs.writeFile(tmpPath, yamlContent, "utf-8");
+  await fs.rename(tmpPath, configPath);
+  return parsed.data;
+}
+async function reloadAgentConfigFromFile(configPath) {
+  return await loadAgentConfig(configPath);
+}
+export {
+  reloadAgentConfigFromFile,
+  updateAgentConfigFile
+};

package/dist/config/error-codes.cjs

@@ -0,0 +1,39 @@
+"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 error_codes_exports = {};
+__export(error_codes_exports, {
+  ConfigErrorCode: () => ConfigErrorCode
+});
+module.exports = __toCommonJS(error_codes_exports);
+var ConfigErrorCode = /* @__PURE__ */ ((ConfigErrorCode2) => {
+  ConfigErrorCode2["FILE_NOT_FOUND"] = "config_file_not_found";
+  ConfigErrorCode2["FILE_READ_ERROR"] = "config_file_read_error";
+  ConfigErrorCode2["FILE_WRITE_ERROR"] = "config_file_write_error";
+  ConfigErrorCode2["PARSE_ERROR"] = "config_parse_error";
+  ConfigErrorCode2["NO_PROJECT_DEFAULT"] = "config_no_project_default";
+  ConfigErrorCode2["NO_GLOBAL_PREFERENCES"] = "config_no_global_preferences";
+  ConfigErrorCode2["SETUP_INCOMPLETE"] = "config_setup_incomplete";
+  ConfigErrorCode2["BUNDLED_NOT_FOUND"] = "config_bundled_not_found";
+  ConfigErrorCode2["UNKNOWN_CONTEXT"] = "config_unknown_context";
+  return ConfigErrorCode2;
+})(ConfigErrorCode || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigErrorCode
+});

package/dist/config/error-codes.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Config-specific error codes
+ * Includes file operations, parsing, and validation errors for configuration management
+ */
+export declare enum ConfigErrorCode {
+    FILE_NOT_FOUND = "config_file_not_found",
+    FILE_READ_ERROR = "config_file_read_error",
+    FILE_WRITE_ERROR = "config_file_write_error",
+    PARSE_ERROR = "config_parse_error",
+    NO_PROJECT_DEFAULT = "config_no_project_default",
+    NO_GLOBAL_PREFERENCES = "config_no_global_preferences",
+    SETUP_INCOMPLETE = "config_setup_incomplete",
+    BUNDLED_NOT_FOUND = "config_bundled_not_found",
+    UNKNOWN_CONTEXT = "config_unknown_context"
+}
+//# sourceMappingURL=error-codes.d.ts.map

package/dist/config/error-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../src/config/error-codes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,eAAe;IAEvB,cAAc,0BAA0B;IACxC,eAAe,2BAA2B;IAC1C,gBAAgB,4BAA4B;IAG5C,WAAW,uBAAuB;IAGlC,kBAAkB,8BAA8B;IAChD,qBAAqB,iCAAiC;IACtD,gBAAgB,4BAA4B;IAC5C,iBAAiB,6BAA6B;IAC9C,eAAe,2BAA2B;CAC7C"}