@agenthippo-ai/agenthippo 0.1.0

package/out/agentpack/manager.js

@@ -0,0 +1,441 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentPackManager = void 0;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+// Lazy-load vscode to allow bundling for CLI/headless mode
+// Use eval to prevent Bun from statically analyzing the require
+let _vscode;
+function getVscode() {
+    if (!_vscode) {
+        // eslint-disable-next-line no-eval
+        _vscode = eval('require')('vscode');
+    }
+    return _vscode;
+}
+const paths_1 = require("./paths");
+const manifest_1 = require("./manifest");
+const utils_1 = require("../utils");
+const stores_1 = require("./stores");
+/**
+ * Manages agent installation, listing, and lifecycle.
+ * All agents (including default) live in .agentide/agents/<agentId>/
+ */
+class AgentPackManager {
+    syncService;
+    getWorkspaceRoot;
+    getStorageUri;
+    outputChannel;
+    constructor(syncService, getWorkspaceRoot, getStorageUri, outputChannel) {
+        this.syncService = syncService;
+        this.getWorkspaceRoot = getWorkspaceRoot;
+        this.getStorageUri = getStorageUri;
+        this.outputChannel = outputChannel;
+    }
+    // -------------------------------------------------------------------------
+    // Agent Installation
+    // -------------------------------------------------------------------------
+    /**
+     * Install an agent from a local directory.
+     * Copies the source directory to .agentide/agents/<agentId>/
+     */
+    async installFromLocal(sourcePath) {
+        const workspaceRoot = this.getWorkspaceRoot();
+        const storageUri = this.getStorageUri();
+        // 1. Validate source has agent.yaml
+        const sourceManifestPath = path.join(sourcePath, paths_1.AGENT_CONSTANTS.MANIFEST_FILE);
+        if (!(await (0, utils_1.pathExists)(sourceManifestPath))) {
+            throw new Error(`No agent.yaml found at ${sourcePath}`);
+        }
+        // 2. Load and validate manifest
+        const manifest = await (0, manifest_1.loadAgentManifest)(sourceManifestPath);
+        const agentId = manifest.metadata.name;
+        const agentVersion = manifest.metadata.version;
+        // 3. Prevent installing over the default agent
+        if ((0, paths_1.isDefaultAgent)(agentId)) {
+            throw new Error('Cannot install an agent with reserved ID "default"');
+        }
+        (0, utils_1.logInfo)(this.outputChannel, `[Agent] Installing: ${agentId}@${agentVersion} from ${sourcePath}`);
+        // 4. Resolve target paths
+        const runtime = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, agentId, agentVersion);
+        // 5. Create agent directories
+        await this.createAgentDirectories(runtime);
+        // 6. Copy source to agent location (if different)
+        const targetPath = runtime.agentRoot;
+        if (path.resolve(sourcePath) !== path.resolve(targetPath)) {
+            (0, utils_1.logInfo)(this.outputChannel, `[Agent] Copying ${sourcePath} to ${targetPath}`);
+            await (0, utils_1.copyDirRecursive)(sourcePath, targetPath);
+        }
+        // 7. Register the agent
+        const installedAgent = await this.registerAgent(agentId, { source: 'local' });
+        // 8. Seed pack data immediately after install (without requiring activation)
+        await this.syncService.seedAgentDataIfNeeded(workspaceRoot, agentId, this.outputChannel);
+        (0, utils_1.logInfo)(this.outputChannel, `[Agent] Successfully installed: ${agentId}@${agentVersion}`);
+        return installedAgent;
+    }
+    /**
+     * Uninstall an agent.
+     */
+    async uninstall(agentId) {
+        const workspaceRoot = this.getWorkspaceRoot();
+        const storageUri = this.getStorageUri();
+        // Prevent uninstalling the default agent
+        if ((0, paths_1.isDefaultAgent)(agentId)) {
+            throw new Error('Cannot uninstall the default agent');
+        }
+        (0, utils_1.logInfo)(this.outputChannel, `[Agent] Uninstalling: ${agentId}`);
+        // 1. Get runtime paths
+        const runtime = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, agentId);
+        // 2. Remove agent directory
+        if (await (0, utils_1.pathExists)(runtime.agentRoot)) {
+            await fs_1.promises.rm(runtime.agentRoot, { recursive: true, force: true });
+            (0, utils_1.logInfo)(this.outputChannel, `[Agent] Removed directory: ${runtime.agentRoot}`);
+        }
+        // 3. Remove SDK config directories
+        if (await (0, utils_1.pathExists)(runtime.codexHome)) {
+            await fs_1.promises.rm(runtime.codexHome, { recursive: true, force: true });
+        }
+        if (await (0, utils_1.pathExists)(runtime.claudeConfigDir)) {
+            await fs_1.promises.rm(runtime.claudeConfigDir, { recursive: true, force: true });
+        }
+        // 4. Update manifest to remove agent
+        await this.syncService.removeInstalledAgent(workspaceRoot, agentId, this.outputChannel);
+        // Notify workbench that packs have changed
+        try {
+            await getVscode().commands.executeCommand('agentide.packsChanged');
+        }
+        catch {
+            // Ignore if workbench command not available
+        }
+        (0, utils_1.logInfo)(this.outputChannel, `[Agent] Successfully uninstalled: ${agentId}`);
+    }
+    // -------------------------------------------------------------------------
+    // Agent Listing
+    // -------------------------------------------------------------------------
+    /**
+     * List all installed agents (including default).
+     */
+    async listInstalled() {
+        const workspaceRoot = this.getWorkspaceRoot();
+        return this.syncService.loadInstalledAgents(workspaceRoot);
+    }
+    /**
+     * Get a specific installed agent by ID.
+     */
+    async getInstalledAgent(agentId) {
+        const agents = await this.listInstalled();
+        return agents.find(a => a.id === agentId);
+    }
+    /**
+     * Check if an agent is installed.
+     */
+    async isInstalled(agentId) {
+        const agent = await this.getInstalledAgent(agentId);
+        return agent !== undefined;
+    }
+    /**
+     * Clean up stale agent entries from the manifest.
+     * Removes entries where the agent folder no longer exists on disk.
+     * @returns List of agent IDs that were removed
+     */
+    async cleanupStaleAgents() {
+        const workspaceRoot = this.getWorkspaceRoot();
+        const agents = await this.listInstalled();
+        const staleIds = [];
+        for (const agent of agents) {
+            const manifestPath = (0, paths_1.getAgentManifestPath)(workspaceRoot, agent.id);
+            if (!(await (0, utils_1.pathExists)(manifestPath))) {
+                staleIds.push(agent.id);
+            }
+        }
+        // Remove stale entries from manifest
+        for (const agentId of staleIds) {
+            (0, utils_1.logInfo)(this.outputChannel, `[Agent] Removing stale entry: ${agentId} (folder missing)`);
+            await this.syncService.removeInstalledAgent(workspaceRoot, agentId, this.outputChannel);
+        }
+        if (staleIds.length > 0) {
+            (0, utils_1.logInfo)(this.outputChannel, `[Agent] Cleaned up ${staleIds.length} stale agent(s)`);
+            // Notify workbench that packs have changed
+            try {
+                await getVscode().commands.executeCommand('agentide.packsChanged');
+            }
+            catch {
+                // Ignore if workbench command not available
+            }
+        }
+        return staleIds;
+    }
+    /**
+     * List all installed agents, optionally cleaning up stale entries first.
+     * @param cleanup If true, removes stale entries before returning
+     */
+    async listInstalledWithCleanup(cleanup = true) {
+        if (cleanup) {
+            await this.cleanupStaleAgents();
+        }
+        return this.listInstalled();
+    }
+    // -------------------------------------------------------------------------
+    // Runtime Paths
+    // -------------------------------------------------------------------------
+    /**
+     * Get runtime paths for an agent.
+     */
+    getAgentRuntimePaths(agentId, agentVersion) {
+        const workspaceRoot = this.getWorkspaceRoot();
+        const storageUri = this.getStorageUri();
+        return (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, agentId, agentVersion);
+    }
+    // -------------------------------------------------------------------------
+    // Internal Helpers
+    // -------------------------------------------------------------------------
+    /**
+     * Create all necessary directories for an agent.
+     */
+    async createAgentDirectories(runtime) {
+        // Agent content directories
+        await fs_1.promises.mkdir(runtime.agentRoot, { recursive: true });
+        await fs_1.promises.mkdir(runtime.rulesDir, { recursive: true });
+        await fs_1.promises.mkdir(runtime.skillsDir, { recursive: true });
+        await fs_1.promises.mkdir(runtime.mcpDir, { recursive: true });
+        // SDK config directories (in storage)
+        await fs_1.promises.mkdir(runtime.codexHome, { recursive: true });
+        await fs_1.promises.mkdir(runtime.claudeConfigDir, { recursive: true });
+    }
+    /**
+     * Create an InstalledAgent entry from an agent on disk.
+     * Loads manifest, computes hashes, and builds the entry.
+     */
+    async buildInstalledAgent(workspaceRoot, agentId, options) {
+        const manifestPath = (0, paths_1.getAgentManifestPath)(workspaceRoot, agentId);
+        const manifest = await (0, manifest_1.loadAgentManifest)(manifestPath);
+        const manifestHashResult = await (0, utils_1.readFileSha256)(manifestPath);
+        // Determine source: builtin for default, otherwise use provided or 'local'
+        const source = options?.source ?? ((0, paths_1.isDefaultAgent)(agentId) ? 'builtin' : 'local');
+        const agentRoot = options?.agentRootOverride ?? `${paths_1.AGENT_CONSTANTS.AGENTS_DIR}/${agentId}`;
+        return {
+            id: agentId,
+            version: manifest.metadata.version,
+            source,
+            installedAt: new Date().toISOString(),
+            manifestHash: manifestHashResult.sha256,
+            featureSetHash: manifestHashResult.sha256,
+            skillsSignature: manifestHashResult.sha256,
+            promptsSignature: manifestHashResult.sha256,
+            agentRoot,
+            preferredEngine: manifest.spec.engine,
+            preferredModel: manifest.spec.model,
+            preferredCheapModel: manifest.spec.cheapModel,
+            status: 'active',
+        };
+    }
+    /**
+     * Register an agent in the manifest (creates InstalledAgent entry and saves).
+     */
+    async registerAgent(agentId, options) {
+        const workspaceRoot = this.getWorkspaceRoot();
+        const installedAgent = await this.buildInstalledAgent(workspaceRoot, agentId, options);
+        await this.syncService.updateInstalledAgent(workspaceRoot, installedAgent, this.outputChannel);
+        // Notify workbench that packs have changed
+        try {
+            await getVscode().commands.executeCommand('agentide.packsChanged');
+        }
+        catch {
+            // Ignore if workbench command not available (e.g., during tests)
+        }
+        return installedAgent;
+    }
+    /**
+     * Discover agents in the agents directory.
+     */
+    async discoverAgents() {
+        const workspaceRoot = this.getWorkspaceRoot();
+        const agentsDir = (0, paths_1.getAgentsDir)(workspaceRoot);
+        if (!(await (0, utils_1.pathExists)(agentsDir))) {
+            return [];
+        }
+        const entries = await fs_1.promises.readdir(agentsDir, { withFileTypes: true });
+        const agentIds = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith('.')) {
+                continue;
+            }
+            const manifestPath = (0, paths_1.getAgentManifestPath)(workspaceRoot, entry.name);
+            if (await (0, utils_1.pathExists)(manifestPath)) {
+                agentIds.push(entry.name);
+            }
+        }
+        return agentIds;
+    }
+    /**
+     * Repair unregistered agents by discovering agents on disk and registering any
+     * that are missing from the manifest.
+     */
+    async repairUnregisteredAgents() {
+        const workspaceRoot = this.getWorkspaceRoot();
+        const agentsDir = (0, paths_1.getAgentsDir)(workspaceRoot);
+        if (!(await (0, utils_1.pathExists)(agentsDir))) {
+            return { registered: [], alreadyRegistered: [] };
+        }
+        // Get currently registered agents
+        const registeredAgents = await this.listInstalled();
+        const registeredIds = new Set(registeredAgents.map(a => a.id));
+        // Discover all agents on disk
+        const discoveredIds = await this.discoverAgents();
+        const registered = [];
+        const alreadyRegistered = [];
+        for (const agentId of discoveredIds) {
+            if (registeredIds.has(agentId)) {
+                alreadyRegistered.push(agentId);
+                continue;
+            }
+            // Agent exists on disk but not in manifest - register it
+            try {
+                await this.registerAgent(agentId);
+                registered.push(agentId);
+                (0, utils_1.logInfo)(this.outputChannel, `[Agent] Repaired: registered untracked agent "${agentId}"`);
+            }
+            catch (e) {
+                (0, utils_1.logInfo)(this.outputChannel, `[Agent] Failed to repair agent "${agentId}": ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        if (registered.length > 0) {
+            (0, utils_1.logInfo)(this.outputChannel, `[Agent] Repair complete: ${registered.length} agent(s) registered`);
+        }
+        return { registered, alreadyRegistered };
+    }
+    // -------------------------------------------------------------------------
+    // Agent Stores Operations (UAL + Hydration)
+    // -------------------------------------------------------------------------
+    /**
+     * Install an agent into the workspace, hydrating from the User Agent Library if needed.
+     *
+     * Notes:
+     * - This does NOT change the active pack (derived dirs). That is handled by `agentide.pack.setActive`.
+     * - This ensures the workspace has a valid `.agentide/agents/<agentId>/` directory and that the agent
+     *   is registered in `agentide.manifest.json`.
+     *
+     * Flow:
+     * 1. If agent exists in workspace, ensure it's registered and use it
+     * 2. If agent is missing/empty, try to hydrate from UAL
+     * 3. Register the agent in the manifest
+     */
+    async installAgentToWorkspace(agentId) {
+        const workspaceRoot = this.getWorkspaceRoot();
+        // Check if agent is available in workspace
+        if (await (0, stores_1.isWorkspaceAgentAvailable)(workspaceRoot, agentId)) {
+            (0, utils_1.logInfo)(this.outputChannel, `[Agent] Agent available in workspace: ${agentId}`);
+            // Ensure it's registered in manifest (fixes "exists on disk but not in installed list")
+            const existing = await this.getInstalledAgent(agentId);
+            if (!existing) {
+                (0, utils_1.logInfo)(this.outputChannel, `[Agent] Registering untracked agent: ${agentId}`);
+                await this.registerAgent(agentId);
+            }
+            await this.syncService.seedAgentDataIfNeeded(workspaceRoot, agentId, this.outputChannel);
+            return { installed: true, hydrated: false };
+        }
+        // Try to hydrate from User Agent Library
+        if (await (0, stores_1.isAgentInUserLibrary)(agentId)) {
+            (0, utils_1.logInfo)(this.outputChannel, `[Agent] Hydrating from User Library: ${agentId}`);
+            const version = await (0, stores_1.hydrateFromUserLibrary)(workspaceRoot, agentId, undefined, this.outputChannel);
+            if (version) {
+                await this.registerAgent(agentId, { source: 'local' });
+                return { installed: true, hydrated: true, version };
+            }
+        }
+        (0, utils_1.logInfo)(this.outputChannel, `[Agent] Agent not found: ${agentId}`);
+        return { installed: false, hydrated: false };
+    }
+    /**
+     * Share/promote an agent to the User Agent Library.
+     */
+    async shareToUserLibrary(agentId) {
+        const workspaceRoot = this.getWorkspaceRoot();
+        return (0, stores_1.promoteToUserLibrary)(workspaceRoot, agentId, this.outputChannel);
+    }
+    /**
+     * Update an agent from the User Agent Library.
+     */
+    async updateFromLibrary(agentId, version) {
+        const workspaceRoot = this.getWorkspaceRoot();
+        return (0, stores_1.updateFromUserLibrary)(workspaceRoot, agentId, version, this.outputChannel);
+    }
+    /**
+     * Duplicate an agent with a new ID.
+     */
+    async duplicate(agentId) {
+        const workspaceRoot = this.getWorkspaceRoot();
+        const newAgentId = await (0, stores_1.duplicateAgent)(workspaceRoot, agentId, this.outputChannel);
+        await this.registerAgent(newAgentId, { source: 'local' });
+        return newAgentId;
+    }
+    /**
+     * Reset the default agent from bundled templates.
+     */
+    async resetDefault(bundledDir) {
+        const workspaceRoot = this.getWorkspaceRoot();
+        await (0, stores_1.resetDefaultAgent)(workspaceRoot, bundledDir, this.outputChannel);
+        // Re-register the default agent
+        const manifestPath = (0, paths_1.getAgentManifestPath)(workspaceRoot, paths_1.AGENT_CONSTANTS.DEFAULT_AGENT_ID);
+        if (await (0, utils_1.pathExists)(manifestPath)) {
+            await this.registerAgent(paths_1.AGENT_CONSTANTS.DEFAULT_AGENT_ID, { source: 'builtin' });
+        }
+    }
+    /**
+     * List agents in the User Agent Library.
+     */
+    async listUserLibrary() {
+        return (0, stores_1.listUserLibraryAgents)();
+    }
+    /**
+     * Check if an update is available for an agent from the User Library.
+     */
+    async checkAgentUpdate(agentId) {
+        const workspaceRoot = this.getWorkspaceRoot();
+        return (0, stores_1.checkForUpdate)(workspaceRoot, agentId);
+    }
+    /**
+     * Get the provenance of a workspace agent.
+     */
+    async getAgentSource(agentId) {
+        const workspaceRoot = this.getWorkspaceRoot();
+        return (0, stores_1.readAgentSource)(workspaceRoot, agentId);
+    }
+}
+exports.AgentPackManager = AgentPackManager;

package/out/agentpack/manifest.js

@@ -0,0 +1,135 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseYaml = parseYaml;
+exports.stringifyYaml = stringifyYaml;
+exports.updateManifestName = updateManifestName;
+exports.loadAgentManifest = loadAgentManifest;
+exports.parseAgentManifest = parseAgentManifest;
+/**
+ * Shared manifest loading and YAML parsing utilities for agent packs.
+ */
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const branding_1 = require("../branding");
+/**
+ * Parse YAML content into an object.
+ */
+function parseYaml(content) {
+    const yaml = require('js-yaml');
+    return yaml.load(content);
+}
+/**
+ * Stringify an object to YAML.
+ */
+function stringifyYaml(obj) {
+    const yaml = require('js-yaml');
+    return yaml.dump(obj, {
+        indent: 2,
+        lineWidth: -1, // Don't wrap lines
+        quotingType: '"',
+        forceQuotes: false,
+    });
+}
+/**
+ * Update the metadata.name field in a YAML manifest file.
+ * Uses proper YAML parsing/serialization to avoid regex issues.
+ */
+async function updateManifestName(manifestPath, newName) {
+    const content = await fs_1.promises.readFile(manifestPath, 'utf8');
+    const manifest = parseYaml(content);
+    if (manifest && typeof manifest === 'object' && manifest.metadata) {
+        manifest.metadata.name = newName;
+    }
+    const updated = stringifyYaml(manifest);
+    await fs_1.promises.writeFile(manifestPath, updated, 'utf8');
+}
+/**
+ * Load and parse an agent manifest from a file path.
+ * Validates required fields and throws if invalid.
+ */
+async function loadAgentManifest(manifestPath) {
+    const content = await fs_1.promises.readFile(manifestPath, 'utf8');
+    return parseAgentManifest(content, manifestPath);
+}
+/**
+ * Parse agent manifest from YAML content.
+ * Validates required fields and throws if invalid.
+ */
+function parseAgentManifest(content, sourcePath) {
+    const manifest = parseYaml(content);
+    const location = sourcePath ? ` (${sourcePath})` : '';
+    if (!manifest?.metadata?.name) {
+        throw new Error(`Manifest missing metadata.name${location}`);
+    }
+    if (!manifest.metadata.version) {
+        throw new Error(`Manifest missing metadata.version${location}`);
+    }
+    if (!manifest.spec?.engine) {
+        throw new Error(`Manifest missing spec.engine${location}`);
+    }
+    validateManifestDataConfig(manifest, location);
+    return manifest;
+}
+function validateManifestDataConfig(manifest, location) {
+    const data = manifest.spec?.data;
+    if (!data) {
+        return;
+    }
+    const validateRelativePath = (value, fieldName, defaultValue) => {
+        const raw = value ?? defaultValue;
+        const trimmed = raw.trim();
+        if (!trimmed) {
+            throw new Error(`Manifest spec.data.${fieldName} cannot be empty${location}`);
+        }
+        if (path.isAbsolute(trimmed)) {
+            throw new Error(`Manifest spec.data.${fieldName} must be relative (not absolute)${location}`);
+        }
+        if (/^(https?:\/\/|git@|ssh:\/\/)/i.test(trimmed)) {
+            throw new Error(`Manifest spec.data.${fieldName} must be a local relative path${location}`);
+        }
+        const normalized = path.posix.normalize(trimmed.replace(/\\/g, '/'));
+        if (normalized === '..' || normalized.startsWith('../')) {
+            throw new Error(`Manifest spec.data.${fieldName} cannot escape parent directories${location}`);
+        }
+    };
+    validateRelativePath(data.sourcePath, 'sourcePath', './data');
+    validateRelativePath(data.workspacePath, 'workspacePath', 
+    // Default only when spec.data.workspacePath is omitted by the user.
+    `${branding_1.AGENTIDE_DIR_NAME}/data/${manifest.metadata.name}`);
+}