@dollhousemcp/mcp-server
Version:
DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.
422 lines • 58.3 kB
JavaScript
/**
* Portfolio Manager - Manages the portfolio directory structure for all element types
*/
import * as path from 'path';
import { homedir } from 'os';
import { logger } from '../utils/logger.js';
import { ElementType } from './types.js';
import { SecurityMonitor } from '../security/securityMonitor.js';
import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
import { DefaultElementProvider } from './DefaultElementProvider.js';
import { ErrorHandler, ErrorCategory } from '../utils/ErrorHandler.js';
// Constants
const ELEMENT_FILE_EXTENSIONS = {
[ElementType.PERSONA]: '.md',
[ElementType.SKILL]: '.md',
[ElementType.TEMPLATE]: '.md',
[ElementType.AGENT]: '.md',
[ElementType.MEMORY]: '.yaml',
[ElementType.ENSEMBLE]: '.md'
};
// Default extension for backward compatibility
const DEFAULT_ELEMENT_FILE_EXTENSION = '.md';
/**
* Get the file extension for an element type without requiring a PortfolioManager instance.
* Issue #815: Shared by PortfolioRepoManager and submitToPortfolioTool to avoid
* hardcoded '.md' assumptions.
*/
export function getElementFileExtension(type) {
return ELEMENT_FILE_EXTENSIONS[type] || DEFAULT_ELEMENT_FILE_EXTENSION;
}
export { ElementType };
export class PortfolioManager {
initializationPromise = null;
baseDir;
fileOperations;
/**
* Create a new PortfolioManager instance
*
* @param config - Optional portfolio configuration
* @param fileOperations - Optional FileOperationsService for dependency injection.
* BREAKING CHANGE (v1.5.0): Added as second parameter for DI.
* Direct instantiation without DI container should pass undefined
* or provide a FileOperationsService instance.
*/
constructor(fileOperations, config) {
this.fileOperations = fileOperations;
// Get potential directory from environment or config
const envDir = process.env.DOLLHOUSE_PORTFOLIO_DIR;
const configDir = config?.baseDir;
const defaultDir = path.join(homedir(), '.dollhouse', 'portfolio');
// Validate environment variable if provided
if (envDir) {
if (!path.isAbsolute(envDir)) {
throw new Error('DOLLHOUSE_PORTFOLIO_DIR must be an absolute path');
}
// Additional validation for suspicious paths
if (envDir.includes('..') || envDir.startsWith('/etc') || envDir.startsWith('/sys')) {
throw new Error('DOLLHOUSE_PORTFOLIO_DIR contains suspicious path segments');
}
}
// Validate config directory if provided
if (configDir && !path.isAbsolute(configDir)) {
throw new Error('Portfolio config baseDir must be an absolute path');
}
// Use environment variable if set, otherwise config, otherwise default
this.baseDir = envDir || configDir || defaultDir;
logger.info(`[PortfolioManager] Portfolio base directory: ${this.baseDir}`);
}
/**
* Get the base portfolio directory
*/
getBaseDir() {
return this.baseDir;
}
/**
* Get the directory for a specific element type
*/
getElementDir(type) {
return path.join(this.baseDir, type);
}
/**
* Get the file extension for a specific element type
* FIX (#1213): Expose ELEMENT_FILE_EXTENSIONS mapping for correct extension display
*/
getFileExtension(type) {
return ELEMENT_FILE_EXTENSIONS[type] || DEFAULT_ELEMENT_FILE_EXTENSION;
}
/**
* Initialize the portfolio directory structure
* Uses locking to prevent race conditions during concurrent initialization
*/
async initialize() {
// If already initializing, wait for the existing initialization
if (this.initializationPromise) {
return this.initializationPromise;
}
// Check if portfolio is fully initialized (base dir + all subdirectories exist)
if (await this.isFullyInitialized()) {
logger.debug('[PortfolioManager] Portfolio already fully initialized');
return;
}
// Create initialization promise to prevent concurrent initialization
this.initializationPromise = this.performInitialization();
try {
await this.initializationPromise;
}
finally {
// Clear the promise after completion
this.initializationPromise = null;
}
}
/**
* Perform the actual initialization - should only be called once
*/
async performInitialization() {
logger.info('[PortfolioManager] Initializing portfolio directory structure');
// Create base directory
try {
await this.fileOperations.createDirectory(this.baseDir);
}
catch (error) {
const err = error;
// In read-only environments (like Docker), we can't create directories
// Log but continue - the portfolio will be empty but functional
if (err.code === 'EACCES' || err.code === 'EROFS' || err.code === 'ENOENT') {
logger.warn(`[PortfolioManager] Cannot create portfolio directory (read-only environment?): ${err.message}`);
logger.info(`[DollhouseMCP] Running in read-only mode - portfolio features disabled`);
return;
}
throw error;
}
// Create subdirectories for each element type
for (const elementType of Object.values(ElementType)) {
const elementDir = path.join(this.baseDir, elementType);
await this.fileOperations.createDirectory(elementDir);
logger.debug(`[PortfolioManager] Created directory: ${elementDir}`);
}
// Create special directories for stateful elements
const agentStateDir = path.join(this.baseDir, ElementType.AGENT, '.state');
await this.fileOperations.createDirectory(agentStateDir);
logger.info('[PortfolioManager] Portfolio directory structure initialized');
// Migration for v1.4.2 users: rename singular directories to plural
await this.migrateFromSingularDirectories();
// Populate with default elements if this is a new installation
// Skip during tests to avoid interference
if (process.env.NODE_ENV !== 'test') {
try {
const defaultProvider = new DefaultElementProvider();
await defaultProvider.populateDefaults(this.baseDir);
}
catch (error) {
logger.error('[PortfolioManager] Error populating default elements:', error);
// Log to stderr for MCP client visibility
logger.error(`[PortfolioManager] CRITICAL: Failed to populate default elements: ${error instanceof Error ? error.message : String(error)}`);
// Continue anyway - empty portfolio is valid
}
}
}
/**
* Check if portfolio directory exists
*/
async exists() {
try {
return await this.fileOperations.exists(this.baseDir);
}
catch {
return false;
}
}
/**
* Check if portfolio is fully initialized (base dir + all subdirectories exist)
* This prevents the bug where base dir exists but subdirectories were deleted
*/
async isFullyInitialized() {
// First check if base directory exists
if (!await this.exists()) {
return false;
}
// Check if all required subdirectories exist
try {
for (const elementType of Object.values(ElementType)) {
const elementDir = path.join(this.baseDir, elementType);
if (!await this.fileOperations.exists(elementDir))
return false;
}
// Check special directories
const agentStateDir = path.join(this.baseDir, ElementType.AGENT, '.state');
if (!await this.fileOperations.exists(agentStateDir))
return false;
return true;
}
catch {
// If any subdirectory is missing, portfolio is not fully initialized
return false;
}
}
/**
* Check if a filename appears to be a test element
* SAFETY: Pattern-based filtering only, no content parsing
*
* This method IDENTIFIES test patterns (always returns true for test files).
* The actual FILTERING decision (whether to exclude them) is made in listElements().
*/
isTestElement(filename) {
// Dangerous test patterns that should never appear in production
const dangerousPatterns = [
/^bin-sh/i,
/^rm-rf/i,
/^nc-e-bin/i,
/^python-c-import/i,
/^curl.*evil/i,
/^wget.*malicious/i,
/^eval-/i,
/^exec-/i,
/^bash-c-/i,
/^sh-c-/i,
/^powershell-/i,
/^cmd-c-/i,
/shell-injection/i
];
// NOTE: Test-pattern filtering removed entirely (Issue #287)
// Users can legitimately create elements with "test" in the name.
// Only dangerous patterns (security concerns) are filtered.
// Check dangerous patterns only
if (dangerousPatterns.some(pattern => pattern.test(filename))) {
logger.warn(`[PortfolioManager] Filtered dangerous element: ${filename}`);
return true;
}
return false;
}
/**
* List all elements of a specific type
*/
async listElements(type) {
const elementDir = this.getElementDir(type);
const fileExtension = ELEMENT_FILE_EXTENSIONS[type] || DEFAULT_ELEMENT_FILE_EXTENSION;
try {
const files = await this.fileOperations.listDirectory(elementDir);
// Filter for correct file extension based on element type
let filteredFiles = files.filter(file => file.endsWith(fileExtension));
// Issue #654: Exclude backup files from all element types.
// Safety net — MemoryStorageLayer also filters, but any code path that
// calls listElements() directly should never return backup artifacts.
filteredFiles = filteredFiles.filter(file => !file.includes('.backup-') && !file.includes('.backup.'));
// Filter out test/dangerous elements unless explicitly disabled
// DISABLE_ELEMENT_FILTERING can be set in E2E tests that need test elements
// Integration tests and production both use filtering by default
const shouldFilter = process.env.DISABLE_ELEMENT_FILTERING !== 'true';
if (shouldFilter) {
filteredFiles = filteredFiles.filter(file => !this.isTestElement(file));
}
return filteredFiles;
}
catch (error) {
const err = error;
if (err.code === 'ENOENT') {
// Directory doesn't exist yet - this is expected for new installations
logger.debug(`[PortfolioManager] Element directory doesn't exist yet: ${elementDir}`);
return [];
}
if (err.code === 'EACCES' || err.code === 'EPERM') {
// Permission denied - log but return empty array
ErrorHandler.logError('PortfolioManager.listElements', error, { elementDir });
return [];
}
if (err.code === 'ENOTDIR') {
// Path exists but is not a directory
ErrorHandler.logError('PortfolioManager.listElements', error, { elementDir });
throw ErrorHandler.createError(`Path is not a directory: ${elementDir}`, ErrorCategory.SYSTEM_ERROR);
}
// For any other errors, throw with context
ErrorHandler.logError('PortfolioManager.listElements', error, { elementDir });
throw ErrorHandler.wrapError(error, 'Failed to list elements', ErrorCategory.SYSTEM_ERROR);
}
}
/**
* Get full path to an element file
*/
getElementPath(type, filename) {
// Validate filename to prevent path traversal
if (!filename || typeof filename !== 'string') {
SecurityMonitor.logSecurityEvent({
type: 'PATH_TRAVERSAL_ATTEMPT',
severity: 'MEDIUM',
source: 'PortfolioManager.getElementPath',
details: `Invalid filename provided: ${typeof filename}`,
additionalData: { elementType: type, filename: String(filename) }
});
throw new Error('Invalid filename: must be a non-empty string');
}
// Check for path traversal attempts
if (filename.includes('..') || filename.includes('/') || filename.includes('\\') || path.isAbsolute(filename)) {
SecurityMonitor.logSecurityEvent({
type: 'PATH_TRAVERSAL_ATTEMPT',
severity: 'HIGH',
source: 'PortfolioManager.getElementPath',
details: `Path traversal attempt detected in filename: ${filename}`,
additionalData: { elementType: type, filename }
});
throw new Error(`Invalid filename: contains path traversal characters: ${filename}`);
}
// Additional validation for hidden files and special characters
if (filename.startsWith('.') || filename.includes('\0')) {
SecurityMonitor.logSecurityEvent({
type: 'PATH_TRAVERSAL_ATTEMPT',
severity: 'MEDIUM',
source: 'PortfolioManager.getElementPath',
details: `Invalid filename characters detected: ${filename}`,
additionalData: { elementType: type, filename, hasHiddenFile: filename.startsWith('.'), hasNullByte: filename.includes('\0') }
});
throw new Error(`Invalid filename: contains invalid characters: ${filename}`);
}
// Ensure filename ends with .md
const safeFilename = filename.endsWith('.md') ? filename : `${filename}.md`;
return path.join(this.getElementDir(type), safeFilename);
}
/**
* Check if an element exists
*/
async elementExists(type, filename) {
try {
return await this.fileOperations.exists(this.getElementPath(type, filename));
}
catch {
return false;
}
}
/**
* Get legacy personas directory path (for migration)
*/
getLegacyPersonasDir() {
return path.join(homedir(), '.dollhouse', 'personas');
}
/**
* Check if legacy personas directory exists
*/
async hasLegacyPersonas() {
try {
const legacyDir = this.getLegacyPersonasDir();
if (!await this.fileOperations.exists(legacyDir))
return false;
const files = await this.fileOperations.listDirectory(legacyDir);
return files.some(file => file.endsWith('.md'));
}
catch {
return false;
}
}
/**
* Get portfolio statistics
*/
async getStatistics() {
const stats = {};
for (const elementType of Object.values(ElementType)) {
const elements = await this.listElements(elementType);
stats[elementType] = elements.length;
}
return stats;
}
/**
* Migrate from v1.4.2 singular directory names to v1.4.3 plural names
* This handles the upgrade path for existing users
*/
async migrateFromSingularDirectories() {
const oldToNew = {
'persona': 'personas',
'skill': 'skills',
'template': 'templates',
'agent': 'agents',
'memory': 'memories',
'ensemble': 'ensembles'
};
for (const [oldName, newName] of Object.entries(oldToNew)) {
// Unicode normalize the directory names (even though they're hardcoded, for security audit)
const normalizedOld = UnicodeValidator.normalize(oldName);
const normalizedNew = UnicodeValidator.normalize(newName);
if (!normalizedOld.isValid || !normalizedNew.isValid) {
// This should never happen with our hardcoded values, but for completeness
logger.error(`[PortfolioManager] Invalid Unicode in directory names during migration`);
continue;
}
const oldDir = path.join(this.baseDir, normalizedOld.normalizedContent);
const newDir = path.join(this.baseDir, normalizedNew.normalizedContent);
try {
// Check if old directory exists
if (!await this.fileOperations.exists(oldDir))
continue;
// Check if new directory already has content
try {
if (await this.fileOperations.exists(newDir)) {
const newDirFiles = await this.fileOperations.listDirectory(newDir);
if (newDirFiles.length > 0) {
logger.warn(`[PortfolioManager] Both ${oldName} and ${newName} directories exist. Keeping ${newName}, skipping migration.`, { oldDir, newDir, fileCount: newDirFiles.length });
continue;
}
}
}
catch {
// New directory doesn't exist or is empty, proceed with migration
}
// Perform the migration
logger.info(`[PortfolioManager] Migrating ${oldName} → ${newName}`);
await this.fileOperations.renameFile(oldDir, newDir);
// Log security event for audit trail
SecurityMonitor.logSecurityEvent({
type: 'DIRECTORY_MIGRATION',
severity: 'LOW',
source: 'PortfolioManager.migrateFromSingularDirectories',
details: `Migrated directory from ${oldName} to ${newName} for v1.4.3 compatibility`,
metadata: { oldDir, newDir }
});
}
catch (error) {
// Old directory doesn't exist, which is fine
if (error.code !== 'ENOENT') {
logger.error(`[PortfolioManager] Error during migration of ${oldName}:`, error);
}
}
}
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PortfolioManager.js","sourceRoot":"","sources":["../../src/portfolio/PortfolioManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Portfolio Manager - Manages the portfolio directory structure for all element types\n */\n\n\nimport * as path from 'path';\nimport { homedir } from 'os';\nimport { logger } from '../utils/logger.js';\nimport { ElementType, PortfolioConfig } from './types.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { DefaultElementProvider } from './DefaultElementProvider.js';\nimport { ErrorHandler, ErrorCategory } from '../utils/ErrorHandler.js';\nimport { FileOperationsService } from '../services/FileOperationsService.js';\n\n// Constants\nconst ELEMENT_FILE_EXTENSIONS: Record<ElementType, string> = {\n  [ElementType.PERSONA]: '.md',\n  [ElementType.SKILL]: '.md',\n  [ElementType.TEMPLATE]: '.md',\n  [ElementType.AGENT]: '.md',\n  [ElementType.MEMORY]: '.yaml',\n  [ElementType.ENSEMBLE]: '.md'\n};\n\n// Default extension for backward compatibility\nconst DEFAULT_ELEMENT_FILE_EXTENSION = '.md';\n\n/**\n * Get the file extension for an element type without requiring a PortfolioManager instance.\n * Issue #815: Shared by PortfolioRepoManager and submitToPortfolioTool to avoid\n * hardcoded '.md' assumptions.\n */\nexport function getElementFileExtension(type: string): string {\n  return ELEMENT_FILE_EXTENSIONS[type as ElementType] || DEFAULT_ELEMENT_FILE_EXTENSION;\n}\n\nexport { ElementType };\nexport type { PortfolioConfig };\n\nexport class PortfolioManager {\n  private initializationPromise: Promise<void> | null = null;\n  private baseDir: string;\n  private fileOperations: FileOperationsService;\n\n  /**\n   * Create a new PortfolioManager instance\n   *\n   * @param config - Optional portfolio configuration\n   * @param fileOperations - Optional FileOperationsService for dependency injection.\n   *                         BREAKING CHANGE (v1.5.0): Added as second parameter for DI.\n   *                         Direct instantiation without DI container should pass undefined\n   *                         or provide a FileOperationsService instance.\n   */\n  constructor(fileOperations: FileOperationsService, config?: PortfolioConfig) {\n    this.fileOperations = fileOperations;\n    // Get potential directory from environment or config\n    const envDir = process.env.DOLLHOUSE_PORTFOLIO_DIR;\n    const configDir = config?.baseDir;\n    const defaultDir = path.join(homedir(), '.dollhouse', 'portfolio');\n    \n    // Validate environment variable if provided\n    if (envDir) {\n      if (!path.isAbsolute(envDir)) {\n        throw new Error('DOLLHOUSE_PORTFOLIO_DIR must be an absolute path');\n      }\n      // Additional validation for suspicious paths\n      if (envDir.includes('..') || envDir.startsWith('/etc') || envDir.startsWith('/sys')) {\n        throw new Error('DOLLHOUSE_PORTFOLIO_DIR contains suspicious path segments');\n      }\n    }\n    \n    // Validate config directory if provided\n    if (configDir && !path.isAbsolute(configDir)) {\n      throw new Error('Portfolio config baseDir must be an absolute path');\n    }\n    \n    // Use environment variable if set, otherwise config, otherwise default\n    this.baseDir = envDir || configDir || defaultDir;\n    \n    logger.info(`[PortfolioManager] Portfolio base directory: ${this.baseDir}`);\n  }\n  \n  /**\n   * Get the base portfolio directory\n   */\n  public getBaseDir(): string {\n    return this.baseDir;\n  }\n  \n  /**\n   * Get the directory for a specific element type\n   */\n  public getElementDir(type: ElementType): string {\n    return path.join(this.baseDir, type);\n  }\n\n  /**\n   * Get the file extension for a specific element type\n   * FIX (#1213): Expose ELEMENT_FILE_EXTENSIONS mapping for correct extension display\n   */\n  public getFileExtension(type: ElementType): string {\n    return ELEMENT_FILE_EXTENSIONS[type] || DEFAULT_ELEMENT_FILE_EXTENSION;\n  }\n\n  /**\n   * Initialize the portfolio directory structure\n   * Uses locking to prevent race conditions during concurrent initialization\n   */\n  public async initialize(): Promise<void> {\n    // If already initializing, wait for the existing initialization\n    if (this.initializationPromise) {\n      return this.initializationPromise;\n    }\n\n    // Check if portfolio is fully initialized (base dir + all subdirectories exist)\n    if (await this.isFullyInitialized()) {\n      logger.debug('[PortfolioManager] Portfolio already fully initialized');\n      return;\n    }\n\n    // Create initialization promise to prevent concurrent initialization\n    this.initializationPromise = this.performInitialization();\n\n    try {\n      await this.initializationPromise;\n    } finally {\n      // Clear the promise after completion\n      this.initializationPromise = null;\n    }\n  }\n  \n  /**\n   * Perform the actual initialization - should only be called once\n   */\n  private async performInitialization(): Promise<void> {\n    logger.info('[PortfolioManager] Initializing portfolio directory structure');\n    \n    // Create base directory\n    try {\n      await this.fileOperations.createDirectory(this.baseDir);\n    } catch (error) {\n      const err = error as NodeJS.ErrnoException;\n      // In read-only environments (like Docker), we can't create directories\n      // Log but continue - the portfolio will be empty but functional\n      if (err.code === 'EACCES' || err.code === 'EROFS' || err.code === 'ENOENT') {\n        logger.warn(`[PortfolioManager] Cannot create portfolio directory (read-only environment?): ${err.message}`);\n        logger.info(`[DollhouseMCP] Running in read-only mode - portfolio features disabled`);\n        return;\n      }\n      throw error;\n    }\n    \n    // Create subdirectories for each element type\n    for (const elementType of Object.values(ElementType)) {\n      const elementDir = path.join(this.baseDir, elementType);\n      await this.fileOperations.createDirectory(elementDir);\n      logger.debug(`[PortfolioManager] Created directory: ${elementDir}`);\n    }\n    \n    // Create special directories for stateful elements\n    const agentStateDir = path.join(this.baseDir, ElementType.AGENT, '.state');\n    await this.fileOperations.createDirectory(agentStateDir);\n    \n    logger.info('[PortfolioManager] Portfolio directory structure initialized');\n    \n    // Migration for v1.4.2 users: rename singular directories to plural\n    await this.migrateFromSingularDirectories();\n    \n    // Populate with default elements if this is a new installation\n    // Skip during tests to avoid interference\n    if (process.env.NODE_ENV !== 'test') {\n      try {\n        const defaultProvider = new DefaultElementProvider();\n        await defaultProvider.populateDefaults(this.baseDir);\n      } catch (error) {\n        logger.error('[PortfolioManager] Error populating default elements:', error);\n        // Log to stderr for MCP client visibility\n        logger.error(`[PortfolioManager] CRITICAL: Failed to populate default elements: ${error instanceof Error ? error.message : String(error)}`);\n        // Continue anyway - empty portfolio is valid\n      }\n    }\n  }\n  \n  /**\n   * Check if portfolio directory exists\n   */\n  public async exists(): Promise<boolean> {\n    try {\n      return await this.fileOperations.exists(this.baseDir);\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Check if portfolio is fully initialized (base dir + all subdirectories exist)\n   * This prevents the bug where base dir exists but subdirectories were deleted\n   */\n  private async isFullyInitialized(): Promise<boolean> {\n    // First check if base directory exists\n    if (!await this.exists()) {\n      return false;\n    }\n\n    // Check if all required subdirectories exist\n    try {\n      for (const elementType of Object.values(ElementType)) {\n        const elementDir = path.join(this.baseDir, elementType);\n        if (!await this.fileOperations.exists(elementDir)) return false;\n      }\n\n      // Check special directories\n      const agentStateDir = path.join(this.baseDir, ElementType.AGENT, '.state');\n      if (!await this.fileOperations.exists(agentStateDir)) return false;\n\n      return true;\n    } catch {\n      // If any subdirectory is missing, portfolio is not fully initialized\n      return false;\n    }\n  }\n  \n  /**\n   * Check if a filename appears to be a test element\n   * SAFETY: Pattern-based filtering only, no content parsing\n   *\n   * This method IDENTIFIES test patterns (always returns true for test files).\n   * The actual FILTERING decision (whether to exclude them) is made in listElements().\n   */\n  public isTestElement(filename: string): boolean {\n    // Dangerous test patterns that should never appear in production\n    const dangerousPatterns = [\n      /^bin-sh/i,\n      /^rm-rf/i,\n      /^nc-e-bin/i,\n      /^python-c-import/i,\n      /^curl.*evil/i,\n      /^wget.*malicious/i,\n      /^eval-/i,\n      /^exec-/i,\n      /^bash-c-/i,\n      /^sh-c-/i,\n      /^powershell-/i,\n      /^cmd-c-/i,\n      /shell-injection/i\n    ];\n\n    // NOTE: Test-pattern filtering removed entirely (Issue #287)\n    // Users can legitimately create elements with \"test\" in the name.\n    // Only dangerous patterns (security concerns) are filtered.\n\n    // Check dangerous patterns only\n    if (dangerousPatterns.some(pattern => pattern.test(filename))) {\n      logger.warn(`[PortfolioManager] Filtered dangerous element: ${filename}`);\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * List all elements of a specific type\n   */\n  public async listElements(type: ElementType): Promise<string[]> {\n    const elementDir = this.getElementDir(type);\n    const fileExtension = ELEMENT_FILE_EXTENSIONS[type] || DEFAULT_ELEMENT_FILE_EXTENSION;\n\n    try {\n      const files = await this.fileOperations.listDirectory(elementDir);\n      // Filter for correct file extension based on element type\n      let filteredFiles = files.filter(file => file.endsWith(fileExtension));\n\n      // Issue #654: Exclude backup files from all element types.\n      // Safety net — MemoryStorageLayer also filters, but any code path that\n      // calls listElements() directly should never return backup artifacts.\n      filteredFiles = filteredFiles.filter(file =>\n        !file.includes('.backup-') && !file.includes('.backup.')\n      );\n\n      // Filter out test/dangerous elements unless explicitly disabled\n      // DISABLE_ELEMENT_FILTERING can be set in E2E tests that need test elements\n      // Integration tests and production both use filtering by default\n      const shouldFilter = process.env.DISABLE_ELEMENT_FILTERING !== 'true';\n      if (shouldFilter) {\n        filteredFiles = filteredFiles.filter(file => !this.isTestElement(file));\n      }\n\n      return filteredFiles;\n    } catch (error) {\n      const err = error as NodeJS.ErrnoException;\n      \n      if (err.code === 'ENOENT') {\n        // Directory doesn't exist yet - this is expected for new installations\n        logger.debug(`[PortfolioManager] Element directory doesn't exist yet: ${elementDir}`);\n        return [];\n      }\n      \n      if (err.code === 'EACCES' || err.code === 'EPERM') {\n        // Permission denied - log but return empty array\n        ErrorHandler.logError('PortfolioManager.listElements', error, { elementDir });\n        return [];\n      }\n      \n      if (err.code === 'ENOTDIR') {\n        // Path exists but is not a directory\n        ErrorHandler.logError('PortfolioManager.listElements', error, { elementDir });\n        throw ErrorHandler.createError(`Path is not a directory: ${elementDir}`, ErrorCategory.SYSTEM_ERROR);\n      }\n      \n      // For any other errors, throw with context\n      ErrorHandler.logError('PortfolioManager.listElements', error, { elementDir });\n      throw ErrorHandler.wrapError(error, 'Failed to list elements', ErrorCategory.SY