@dollhousemcp/mcp-server 1.5.2 → 1.6.0

package/dist/services/BuildInfoService.js

@@ -0,0 +1,271 @@
+/**
+ * BuildInfoService - Provides build and runtime information
+ * Separated from main index.ts to avoid making that file larger
+ *
+ * SECURITY FIX (PR #614):
+ * 1. DMCP-SEC-004: FALSE POSITIVE SUPPRESSION - No user input Unicode normalization needed
+ *    This service only processes system information (git, package.json, environment variables)
+ *    The MCP tool 'get_build_info' takes NO parameters (empty inputSchema)
+ *    No user-provided data flows through this service that requires Unicode normalization
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+import { logger } from '../utils/logger.js';
+export class BuildInfoService {
+    static instance;
+    startTime;
+    packageInfo;
+    constructor() {
+        this.startTime = new Date();
+    }
+    static getInstance() {
+        if (!BuildInfoService.instance) {
+            BuildInfoService.instance = new BuildInfoService();
+        }
+        return BuildInfoService.instance;
+    }
+    /**
+     * Get comprehensive build information
+     * SECURITY NOTE: This method processes only system-generated data
+     * No user input is involved - all data comes from filesystem, git, and Node.js process
+     */
+    async getBuildInfo() {
+        const [packageInfo, gitInfo, dockerInfo] = await Promise.all([
+            this.getPackageInfo(),
+            this.getGitInfo(),
+            this.getDockerInfo()
+        ]);
+        const buildTimestamp = await this.getBuildTimestamp();
+        return {
+            package: packageInfo,
+            build: {
+                timestamp: buildTimestamp,
+                type: gitInfo.commit ? 'git' : buildTimestamp ? 'npm' : 'unknown',
+                gitCommit: gitInfo.commit,
+                gitBranch: gitInfo.branch
+            },
+            runtime: {
+                nodeVersion: process.version,
+                platform: process.platform,
+                arch: process.arch,
+                uptime: process.uptime(),
+                memoryUsage: process.memoryUsage()
+            },
+            environment: {
+                nodeEnv: process.env.NODE_ENV,
+                isProduction: process.env.NODE_ENV === 'production',
+                isDevelopment: process.env.NODE_ENV === 'development',
+                isDebug: process.env.DEBUG === 'true' || process.env.DEBUG === '1',
+                isDocker: dockerInfo.isDocker,
+                dockerInfo: dockerInfo.info
+            },
+            server: {
+                startTime: this.startTime,
+                uptime: Date.now() - this.startTime.getTime(),
+                mcpConnection: true // We're connected if this method is being called via MCP
+            }
+        };
+    }
+    /**
+     * Format build info as user-friendly markdown
+     * SECURITY NOTE: Only formats system-generated data - no user input processing
+     * All input data comes from getBuildInfo() which only reads system information
+     */
+    formatBuildInfo(info) {
+        const lines = [];
+        lines.push('# 🔧 Build Information\n');
+        // Package info
+        lines.push('## 📦 Package');
+        lines.push(`- **Name**: ${info.package.name}`);
+        lines.push(`- **Version**: ${info.package.version}`);
+        lines.push('');
+        // Build info
+        lines.push('## 🏗️ Build');
+        lines.push(`- **Type**: ${info.build.type}`);
+        if (info.build.timestamp) {
+            lines.push(`- **Timestamp**: ${info.build.timestamp}`);
+        }
+        if (info.build.gitCommit) {
+            lines.push(`- **Git Commit**: \`${info.build.gitCommit}\``);
+        }
+        if (info.build.gitBranch) {
+            lines.push(`- **Git Branch**: ${info.build.gitBranch}`);
+        }
+        lines.push('');
+        // Runtime info
+        lines.push('## 💻 Runtime');
+        lines.push(`- **Node.js**: ${info.runtime.nodeVersion}`);
+        lines.push(`- **Platform**: ${info.runtime.platform}`);
+        lines.push(`- **Architecture**: ${info.runtime.arch}`);
+        lines.push(`- **Process Uptime**: ${this.formatUptime(info.runtime.uptime)}`);
+        lines.push(`- **Memory Usage**: ${this.formatMemory(info.runtime.memoryUsage.heapUsed)} / ${this.formatMemory(info.runtime.memoryUsage.heapTotal)}`);
+        lines.push('');
+        // Environment info
+        lines.push('## ⚙️ Environment');
+        lines.push(`- **NODE_ENV**: ${info.environment.nodeEnv || 'not set'}`);
+        lines.push(`- **Mode**: ${info.environment.isProduction ? 'Production' : info.environment.isDevelopment ? 'Development' : 'Unknown'}`);
+        lines.push(`- **Debug**: ${info.environment.isDebug ? 'Enabled' : 'Disabled'}`);
+        lines.push(`- **Docker**: ${info.environment.isDocker ? 'Yes' : 'No'}`);
+        if (info.environment.dockerInfo) {
+            lines.push(`- **Container**: ${info.environment.dockerInfo}`);
+        }
+        lines.push('');
+        // Server info
+        lines.push('## 🚀 Server');
+        lines.push(`- **Started**: ${info.server.startTime.toISOString()}`);
+        lines.push(`- **Uptime**: ${this.formatUptime(info.server.uptime / 1000)}`);
+        lines.push(`- **MCP Connection**: ${info.server.mcpConnection ? '✅ Connected' : '❌ Disconnected'}`);
+        return lines.join('\n');
+    }
+    /**
+     * SECURITY NOTE: No Unicode normalization needed - reads application's own package.json
+     * Data source: Controlled file system path, no user input
+     */
+    async getPackageInfo() {
+        if (this.packageInfo) {
+            return this.packageInfo;
+        }
+        try {
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = path.dirname(__filename);
+            // Try multiple paths to find package.json
+            // This handles both normal execution and compiled test scenarios
+            const possiblePaths = [
+                path.join(__dirname, '..', '..', 'package.json'), // Normal: dist/services -> root
+                path.join(__dirname, '..', '..', '..', 'package.json'), // Test: dist/test/services -> root
+                path.join(__dirname, '..', '..', '..', '..', 'package.json'), // Deep test: dist/test/deep/services -> root
+                path.join(process.cwd(), 'package.json') // Fallback to current working directory
+            ];
+            let pkg = null;
+            for (const packagePath of possiblePaths) {
+                try {
+                    // SECURITY NOTE: Reading our own package.json file - not user input
+                    // This file is controlled by the application, no Unicode normalization needed
+                    const content = await fs.readFile(packagePath, 'utf-8');
+                    pkg = JSON.parse(content);
+                    break;
+                }
+                catch {
+                    // Try next path
+                    continue;
+                }
+            }
+            if (!pkg) {
+                throw new Error('Could not find package.json in any expected location');
+            }
+            this.packageInfo = {
+                name: pkg.name || 'unknown',
+                version: pkg.version || 'unknown'
+            };
+            return this.packageInfo;
+        }
+        catch (error) {
+            logger.debug('Failed to read package.json:', error);
+            return { name: 'unknown', version: 'unknown' };
+        }
+    }
+    /**
+     * SECURITY NOTE: No Unicode normalization needed - reads build-generated version file
+     * Data source: Build system output file, no user input
+     */
+    async getBuildTimestamp() {
+        try {
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = path.dirname(__filename);
+            // Try multiple paths to find version.json
+            // This handles both normal execution and compiled test scenarios
+            const possiblePaths = [
+                path.join(__dirname, '..', '..', 'dist', 'version.json'), // Normal location
+                path.join(__dirname, '..', '..', '..', 'dist', 'version.json'), // Test scenario
+                path.join(process.cwd(), 'dist', 'version.json') // Fallback to cwd
+            ];
+            for (const versionPath of possiblePaths) {
+                try {
+                    const content = await fs.readFile(versionPath, 'utf-8');
+                    const version = JSON.parse(content);
+                    return version.buildTime || version.timestamp;
+                }
+                catch {
+                    // Try next path
+                    continue;
+                }
+            }
+            // Version file might not exist, that's okay
+            return undefined;
+        }
+        catch {
+            // Version file might not exist, that's okay
+            return undefined;
+        }
+    }
+    /**
+     * SECURITY NOTE: No Unicode normalization needed - executes system git commands
+     * Data source: Git CLI output (system-controlled), no user input
+     */
+    async getGitInfo() {
+        try {
+            // SECURITY NOTE: Git commands return system-controlled data - not user input
+            // Git commit hashes and branch names are controlled by git, no Unicode normalization needed
+            const commit = execSync('git rev-parse --short HEAD', { encoding: 'utf-8' }).trim();
+            const branch = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
+            return { commit, branch };
+        }
+        catch {
+            // Not in a git repository or git not available
+            return {};
+        }
+    }
+    /**
+     * SECURITY NOTE: No Unicode normalization needed - reads container runtime files
+     * Data source: System cgroup files (container-controlled), no user input
+     */
+    async getDockerInfo() {
+        try {
+            // SECURITY NOTE: Reading system cgroup file - controlled by container runtime, not user input
+            // Container runtime generates this file content, no Unicode normalization needed
+            const cgroupContent = await fs.readFile('/proc/1/cgroup', 'utf-8');
+            const isDocker = cgroupContent.includes('docker') || cgroupContent.includes('containerd');
+            if (isDocker) {
+                // Try to get container ID
+                const containerId = cgroupContent
+                    .split('\n')
+                    .find(line => line.includes('docker'))
+                    ?.split('/')
+                    .pop()
+                    ?.substring(0, 12);
+                return {
+                    isDocker: true,
+                    info: containerId ? `Container ID: ${containerId}` : 'Running in Docker'
+                };
+            }
+            return { isDocker: false };
+        }
+        catch {
+            // Not in Docker or /proc not available
+            return { isDocker: false };
+        }
+    }
+    formatUptime(seconds) {
+        const days = Math.floor(seconds / 86400);
+        const hours = Math.floor((seconds % 86400) / 3600);
+        const minutes = Math.floor((seconds % 3600) / 60);
+        const secs = Math.floor(seconds % 60);
+        const parts = [];
+        if (days > 0)
+            parts.push(`${days}d`);
+        if (hours > 0)
+            parts.push(`${hours}h`);
+        if (minutes > 0)
+            parts.push(`${minutes}m`);
+        if (secs > 0 || parts.length === 0)
+            parts.push(`${secs}s`);
+        return parts.join(' ');
+    }
+    formatMemory(bytes) {
+        const mb = bytes / 1024 / 1024;
+        return `${mb.toFixed(1)} MB`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BuildInfoService.js","sourceRoot":"","sources":["../../src/services/BuildInfoService.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * BuildInfoService - Provides build and runtime information\n * Separated from main index.ts to avoid making that file larger\n * \n * SECURITY FIX (PR #614):\n * 1. DMCP-SEC-004: FALSE POSITIVE SUPPRESSION - No user input Unicode normalization needed\n *    This service only processes system information (git, package.json, environment variables)\n *    The MCP tool 'get_build_info' takes NO parameters (empty inputSchema)\n *    No user-provided data flows through this service that requires Unicode normalization\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { fileURLToPath } from 'url';\nimport { execSync } from 'child_process';\nimport { logger } from '../utils/logger.js';\n\nexport interface BuildInfo {\n  package: {\n    name: string;\n    version: string;\n  };\n  build: {\n    timestamp?: string;\n    type: 'git' | 'npm' | 'unknown';\n    gitCommit?: string;\n    gitBranch?: string;\n  };\n  runtime: {\n    nodeVersion: string;\n    platform: string;\n    arch: string;\n    uptime: number;\n    memoryUsage: NodeJS.MemoryUsage;\n  };\n  environment: {\n    nodeEnv?: string;\n    isProduction: boolean;\n    isDevelopment: boolean;\n    isDebug: boolean;\n    isDocker: boolean;\n    dockerInfo?: string;\n  };\n  server: {\n    startTime: Date;\n    uptime: number;\n    mcpConnection: boolean;\n  };\n}\n\nexport class BuildInfoService {\n  private static instance: BuildInfoService;\n  private readonly startTime: Date;\n  private packageInfo?: { name: string; version: string };\n\n  private constructor() {\n    this.startTime = new Date();\n  }\n\n  public static getInstance(): BuildInfoService {\n    if (!BuildInfoService.instance) {\n      BuildInfoService.instance = new BuildInfoService();\n    }\n    return BuildInfoService.instance;\n  }\n\n  /**\n   * Get comprehensive build information\n   * SECURITY NOTE: This method processes only system-generated data\n   * No user input is involved - all data comes from filesystem, git, and Node.js process\n   */\n  public async getBuildInfo(): Promise<BuildInfo> {\n    const [packageInfo, gitInfo, dockerInfo] = await Promise.all([\n      this.getPackageInfo(),\n      this.getGitInfo(),\n      this.getDockerInfo()\n    ]);\n\n    const buildTimestamp = await this.getBuildTimestamp();\n\n    return {\n      package: packageInfo,\n      build: {\n        timestamp: buildTimestamp,\n        type: gitInfo.commit ? 'git' : buildTimestamp ? 'npm' : 'unknown',\n        gitCommit: gitInfo.commit,\n        gitBranch: gitInfo.branch\n      },\n      runtime: {\n        nodeVersion: process.version,\n        platform: process.platform,\n        arch: process.arch,\n        uptime: process.uptime(),\n        memoryUsage: process.memoryUsage()\n      },\n      environment: {\n        nodeEnv: process.env.NODE_ENV,\n        isProduction: process.env.NODE_ENV === 'production',\n        isDevelopment: process.env.NODE_ENV === 'development',\n        isDebug: process.env.DEBUG === 'true' || process.env.DEBUG === '1',\n        isDocker: dockerInfo.isDocker,\n        dockerInfo: dockerInfo.info\n      },\n      server: {\n        startTime: this.startTime,\n        uptime: Date.now() - this.startTime.getTime(),\n        mcpConnection: true // We're connected if this method is being called via MCP\n      }\n    };\n  }\n\n  /**\n   * Format build info as user-friendly markdown\n   * SECURITY NOTE: Only formats system-generated data - no user input processing\n   * All input data comes from getBuildInfo() which only reads system information\n   */\n  public formatBuildInfo(info: BuildInfo): string {\n    const lines: string[] = [];\n    \n    lines.push('# 🔧 Build Information\\n');\n    \n    // Package info\n    lines.push('## 📦 Package');\n    lines.push(`- **Name**: ${info.package.name}`);\n    lines.push(`- **Version**: ${info.package.version}`);\n    lines.push('');\n    \n    // Build info\n    lines.push('## 🏗️ Build');\n    lines.push(`- **Type**: ${info.build.type}`);\n    if (info.build.timestamp) {\n      lines.push(`- **Timestamp**: ${info.build.timestamp}`);\n    }\n    if (info.build.gitCommit) {\n      lines.push(`- **Git Commit**: \\`${info.build.gitCommit}\\``);\n    }\n    if (info.build.gitBranch) {\n      lines.push(`- **Git Branch**: ${info.build.gitBranch}`);\n    }\n    lines.push('');\n    \n    // Runtime info\n    lines.push('## 💻 Runtime');\n    lines.push(`- **Node.js**: ${info.runtime.nodeVersion}`);\n    lines.push(`- **Platform**: ${info.runtime.platform}`);\n    lines.push(`- **Architecture**: ${info.runtime.arch}`);\n    lines.push(`- **Process Uptime**: ${this.formatUptime(info.runtime.uptime)}`);\n    lines.push(`- **Memory Usage**: ${this.formatMemory(info.runtime.memoryUsage.heapUsed)} / ${this.formatMemory(info.runtime.memoryUsage.heapTotal)}`);\n    lines.push('');\n    \n    // Environment info\n    lines.push('## ⚙️ Environment');\n    lines.push(`- **NODE_ENV**: ${info.environment.nodeEnv || 'not set'}`);\n    lines.push(`- **Mode**: ${info.environment.isProduction ? 'Production' : info.environment.isDevelopment ? 'Development' : 'Unknown'}`);\n    lines.push(`- **Debug**: ${info.environment.isDebug ? 'Enabled' : 'Disabled'}`);\n    lines.push(`- **Docker**: ${info.environment.isDocker ? 'Yes' : 'No'}`);\n    if (info.environment.dockerInfo) {\n      lines.push(`- **Container**: ${info.environment.dockerInfo}`);\n    }\n    lines.push('');\n    \n    // Server info\n    lines.push('## 🚀 Server');\n    lines.push(`- **Started**: ${info.server.startTime.toISOString()}`);\n    lines.push(`- **Uptime**: ${this.formatUptime(info.server.uptime / 1000)}`);\n    lines.push(`- **MCP Connection**: ${info.server.mcpConnection ? '✅ Connected' : '❌ Disconnected'}`);\n    \n    return lines.join('\\n');\n  }\n\n  /**\n   * SECURITY NOTE: No Unicode normalization needed - reads application's own package.json\n   * Data source: Controlled file system path, no user input\n   */\n  private async getPackageInfo(): Promise<{ name: string; version: string }> {\n    if (this.packageInfo) {\n      return this.packageInfo;\n    }\n\n    try {\n      const __filename = fileURLToPath(import.meta.url);\n      const __dirname = path.dirname(__filename);\n      \n      // Try multiple paths to find package.json\n      // This handles both normal execution and compiled test scenarios\n      const possiblePaths = [\n        path.join(__dirname, '..', '..', 'package.json'), // Normal: dist/services -> root\n        path.join(__dirname, '..', '..', '..', 'package.json'), // Test: dist/test/services -> root\n        path.join(__dirname, '..', '..', '..', '..', 'package.json'), // Deep test: dist/test/deep/services -> root\n        path.join(process.cwd(), 'package.json') // Fallback to current working directory\n      ];\n      \n      let pkg: any = null;\n      \n      for (const packagePath of possiblePaths) {\n        try {\n          // SECURITY NOTE: Reading our own package.json file - not user input\n          // This file is controlled by the application, no Unicode normalization needed\n          const content = await fs.readFile(packagePath, 'utf-8');\n          pkg = JSON.parse(content);\n          break;\n        } catch {\n          // Try next path\n          continue;\n        }\n      }\n      \n      if (!pkg) {\n        throw new Error('Could not find package.json in any expected location');\n      }\n      \n      this.packageInfo = {\n        name: pkg.name || 'unknown',\n        version: pkg.version || 'unknown'\n      };\n      \n      return this.packageInfo;\n    } catch (error) {\n      logger.debug('Failed to read package.json:', error);\n      return { name: 'unknown', version: 'unknown' };\n    }\n  }\n\n  /**\n   * SECURITY NOTE: No Unicode normalization needed - reads build-generated version file\n   * Data source: Build system output file, no user input\n   */\n  private async getBuildTimestamp(): Promise<string | undefined> {\n    try {\n      const __filename = fileURLToPath(import.meta.url);\n      const __dirname = path.dirname(__filename);\n      \n      // Try multiple paths to find version.json\n      // This handles both normal execution and compiled test scenarios\n      const possiblePaths = [\n        path.join(__dirname, '..', '..', 'dist', 'version.json'), // Normal location\n        path.join(__dirname, '..', '..', '..', 'dist', 'version.json'), // Test scenario\n        path.join(process.cwd(), 'dist', 'version.json') // Fallback to cwd\n      ];\n      \n      for (const versionPath of possiblePaths) {\n        try {\n          const content = await fs.readFile(versionPath, 'utf-8');\n          const version = JSON.parse(content);\n          return version.buildTime || version.timestamp;\n        } catch {\n          // Try next path\n          continue;\n        }\n      }\n      \n      // Version file might not exist, that's okay\n      return undefined;\n    } catch {\n      // Version file might not exist, that's okay\n      return undefined;\n    }\n  }\n\n  /**\n   * SECURITY NOTE: No Unicode normalization needed - executes system git commands\n   * Data source: Git CLI output (system-controlled), no user input\n   */\n  private async getGitInfo(): Promise<{ commit?: string; branch?: string }> {\n    try {\n      // SECURITY NOTE: Git commands return system-controlled data - not user input\n      // Git commit hashes and branch names are controlled by git, no Unicode normalization needed\n      const commit = execSync('git rev-parse --short HEAD', { encoding: 'utf-8' }).trim();\n      const branch = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();\n      \n      return { commit, branch };\n    } catch {\n      // Not in a git repository or git not available\n      return {};\n    }\n  }\n\n  /**\n   * SECURITY NOTE: No Unicode normalization needed - reads container runtime files\n   * Data source: System cgroup files (container-controlled), no user input\n   */\n  private async getDockerInfo(): Promise<{ isDocker: boolean; info?: string }> {\n    try {\n      // SECURITY NOTE: Reading system cgroup file - controlled by container runtime, not user input\n      // Container runtime generates this file content, no Unicode normalization needed\n      const cgroupContent = await fs.readFile('/proc/1/cgroup', 'utf-8');\n      const isDocker = cgroupContent.includes('docker') || cgroupContent.includes('containerd');\n      \n      if (isDocker) {\n        // Try to get container ID\n        const containerId = cgroupContent\n          .split('\\n')\n          .find(line => line.includes('docker'))\n          ?.split('/')\n          .pop()\n          ?.substring(0, 12);\n        \n        return {\n          isDocker: true,\n          info: containerId ? `Container ID: ${containerId}` : 'Running in Docker'\n        };\n      }\n      \n      return { isDocker: false };\n    } catch {\n      // Not in Docker or /proc not available\n      return { isDocker: false };\n    }\n  }\n\n  private formatUptime(seconds: number): string {\n    const days = Math.floor(seconds / 86400);\n    const hours = Math.floor((seconds % 86400) / 3600);\n    const minutes = Math.floor((seconds % 3600) / 60);\n    const secs = Math.floor(seconds % 60);\n    \n    const parts: string[] = [];\n    if (days > 0) parts.push(`${days}d`);\n    if (hours > 0) parts.push(`${hours}h`);\n    if (minutes > 0) parts.push(`${minutes}m`);\n    if (secs > 0 || parts.length === 0) parts.push(`${secs}s`);\n    \n    return parts.join(' ');\n  }\n\n  private formatMemory(bytes: number): string {\n    const mb = bytes / 1024 / 1024;\n    return `${mb.toFixed(1)} MB`;\n  }\n}"]}

package/dist/tools/portfolio/PortfolioElementAdapter.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Adapter to convert simple portfolio elements to full IElement interface
+ * This resolves type safety issues without complex type casting
+ *
+ * FIXES IMPLEMENTED (PR #503):
+ * 1. TYPE SAFETY (Issue #497): Eliminates complex type casting with adapter pattern
+ * 2. SECURITY FIX DMCP-SEC-004 (MEDIUM): Added Unicode normalization for all user input
+ * 3. SECURITY FIX DMCP-SEC-006 (LOW): Added audit logging for element creation
+ * 4. PERFORMANCE: Helper methods for efficient string normalization
+ */
+import { IElement, IElementMetadata, ElementValidationResult, ElementStatus } from '../../types/elements/IElement.js';
+import { ElementType } from '../../portfolio/types.js';
+import { PortfolioElement } from './submitToPortfolioTool.js';
+/**
+ * Adapter class that wraps a simple PortfolioElement and implements IElement
+ * This allows us to pass portfolio elements to methods expecting IElement
+ * without complex type casting
+ */
+export declare class PortfolioElementAdapter implements IElement {
+    readonly id: string;
+    readonly type: ElementType;
+    readonly version: string;
+    readonly metadata: IElementMetadata;
+    private readonly portfolioElement;
+    constructor(element: PortfolioElement);
+    /**
+     * Helper to normalize string values safely
+     */
+    private normalizeString;
+    /**
+     * Validate the element
+     */
+    validate(): ElementValidationResult;
+    /**
+     * Serialize the element to markdown with YAML frontmatter
+     * FIX: Changed from JSON to markdown format for GitHub portfolio compatibility
+     * SECURITY FIX #544: Parse and validate existing frontmatter instead of returning as-is
+     * SECURITY FIX #543: Use gray-matter for robust frontmatter detection
+     */
+    serialize(): string;
+    /**
+     * Deserialize from string (not implemented for adapter)
+     */
+    deserialize(data: string): void;
+    /**
+     * Get element status
+     */
+    getStatus(): ElementStatus;
+    /**
+     * Get the original portfolio element content
+     */
+    getContent(): string;
+}
+//# sourceMappingURL=PortfolioElementAdapter.d.ts.map

package/dist/tools/portfolio/PortfolioElementAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PortfolioElementAdapter.d.ts","sourceRoot":"","sources":["../../../src/tools/portfolio/PortfolioElementAdapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,uBAAuB,EACvB,aAAa,EAGd,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAQ9D;;;;GAIG;AACH,qBAAa,uBAAwB,YAAW,QAAQ;IACtD,SAAgB,EAAE,EAAE,MAAM,CAAC;IAC3B,SAAgB,IAAI,EAAE,WAAW,CAAC;IAClC,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,SAAgB,QAAQ,EAAE,gBAAgB,CAAC;IAC3C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmB;gBAExC,OAAO,EAAE,gBAAgB;IAsDrC;;OAEG;IACH,OAAO,CAAC,eAAe;IAMvB;;OAEG;IACH,QAAQ,IAAI,uBAAuB;IAyBnC;;;;;OAKG;IACH,SAAS,IAAI,MAAM;IA2GnB;;OAEG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI/B;;OAEG;IACH,SAAS,IAAI,aAAa;IAI1B;;OAEG;IACH,UAAU,IAAI,MAAM;CAGrB"}

package/dist/tools/portfolio/PortfolioElementAdapter.js

@@ -0,0 +1,229 @@
+/**
+ * Adapter to convert simple portfolio elements to full IElement interface
+ * This resolves type safety issues without complex type casting
+ *
+ * FIXES IMPLEMENTED (PR #503):
+ * 1. TYPE SAFETY (Issue #497): Eliminates complex type casting with adapter pattern
+ * 2. SECURITY FIX DMCP-SEC-004 (MEDIUM): Added Unicode normalization for all user input
+ * 3. SECURITY FIX DMCP-SEC-006 (LOW): Added audit logging for element creation
+ * 4. PERFORMANCE: Helper methods for efficient string normalization
+ */
+import { ElementStatus } from '../../types/elements/IElement.js';
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
+import { SecurityMonitor } from '../../security/securityMonitor.js';
+import { logger } from '../../utils/logger.js';
+import * as yaml from 'js-yaml';
+import matter from 'gray-matter';
+import { ContentValidator } from '../../security/contentValidator.js';
+/**
+ * Adapter class that wraps a simple PortfolioElement and implements IElement
+ * This allows us to pass portfolio elements to methods expecting IElement
+ * without complex type casting
+ */
+export class PortfolioElementAdapter {
+    id;
+    type;
+    version;
+    metadata;
+    portfolioElement;
+    constructor(element) {
+        // SECURITY FIX #2 (DMCP-SEC-004): Normalize and validate all user input
+        // Previously: User input was used directly without validation
+        // Now: All string inputs go through UnicodeValidator to prevent homograph attacks
+        const normalizedName = UnicodeValidator.normalize(element.metadata.name);
+        if (!normalizedName.isValid) {
+            // Log security event for invalid Unicode
+            SecurityMonitor.logSecurityEvent({
+                type: 'UNICODE_VALIDATION_ERROR',
+                severity: 'MEDIUM',
+                source: 'PortfolioElementAdapter.constructor',
+                details: `Invalid Unicode in element name: ${normalizedName.detectedIssues?.[0] || 'unknown'}`
+            });
+            logger.warn('Invalid Unicode detected in element name', {
+                issues: normalizedName.detectedIssues
+            });
+        }
+        this.portfolioElement = element;
+        this.type = element.type;
+        this.version = element.metadata.version || '1.0.0';
+        // Generate ID from type and normalized name
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const safeName = normalizedName.normalizedContent || element.metadata.name;
+        const nameSlug = safeName.toLowerCase().replace(/\s+/g, '-');
+        this.id = `${element.type}_${nameSlug}_${timestamp}`;
+        // Convert metadata to IElementMetadata format with normalized values
+        this.metadata = {
+            name: safeName,
+            description: this.normalizeString(element.metadata.description || ''),
+            author: this.normalizeString(element.metadata.author || ''),
+            version: element.metadata.version,
+            created: element.metadata.created,
+            modified: element.metadata.updated,
+            tags: []
+        };
+        // SECURITY FIX #3 (DMCP-SEC-006): Log element creation for audit trail
+        // Previously: No audit logging for portfolio operations
+        // Now: Complete audit trail using SecurityMonitor.logSecurityEvent()
+        SecurityMonitor.logSecurityEvent({
+            type: 'ELEMENT_CREATED',
+            severity: 'LOW',
+            source: 'PortfolioElementAdapter.constructor',
+            details: `Created portfolio element adapter: ${this.id}`,
+            metadata: {
+                elementType: this.type,
+                elementId: this.id
+            }
+        });
+    }
+    /**
+     * Helper to normalize string values safely
+     */
+    normalizeString(value) {
+        if (!value)
+            return value;
+        const normalized = UnicodeValidator.normalize(value);
+        return normalized.normalizedContent || value;
+    }
+    /**
+     * Validate the element
+     */
+    validate() {
+        const errors = [];
+        const warnings = [];
+        if (!this.metadata.name) {
+            errors.push({
+                field: 'name',
+                message: 'Element name is required'
+            });
+        }
+        if (!this.portfolioElement.content) {
+            errors.push({
+                field: 'content',
+                message: 'Element content is required'
+            });
+        }
+        return {
+            valid: errors.length === 0,
+            errors: errors.length > 0 ? errors : undefined,
+            warnings: warnings.length > 0 ? warnings : undefined
+        };
+    }
+    /**
+     * Serialize the element to markdown with YAML frontmatter
+     * FIX: Changed from JSON to markdown format for GitHub portfolio compatibility
+     * SECURITY FIX #544: Parse and validate existing frontmatter instead of returning as-is
+     * SECURITY FIX #543: Use gray-matter for robust frontmatter detection
+     */
+    serialize() {
+        // SECURITY FIX #543: Use gray-matter for robust frontmatter detection
+        // This handles different line endings, whitespace variations, and malformed YAML
+        let contentToProcess = this.portfolioElement.content;
+        let existingMetadata = {};
+        let bodyContent = contentToProcess;
+        // Try to parse existing frontmatter if present
+        try {
+            // gray-matter handles all edge cases:
+            // - Different line endings (\n, \r\n)
+            // - Whitespace variations
+            // - Malformed YAML (returns empty data object)
+            // - Missing closing delimiter
+            const parsed = matter(contentToProcess);
+            if (parsed.data && Object.keys(parsed.data).length > 0) {
+                // SECURITY FIX #544: Validate existing frontmatter instead of bypassing
+                logger.debug('Found existing frontmatter, validating before merge');
+                // Validate the parsed frontmatter
+                const validationResult = ContentValidator.validateAndSanitize(yaml.dump(parsed.data));
+                if (!validationResult.isValid && validationResult.severity === 'critical') {
+                    // Log security event for malicious frontmatter
+                    SecurityMonitor.logSecurityEvent({
+                        type: 'CONTENT_INJECTION_ATTEMPT',
+                        severity: 'HIGH',
+                        source: 'PortfolioElementAdapter.serialize',
+                        details: `Critical security issues in frontmatter: ${validationResult.detectedPatterns?.join(', ')}`,
+                        metadata: {
+                            elementId: this.id,
+                            elementType: this.type
+                        }
+                    });
+                    // Don't use the malicious frontmatter, create new
+                    existingMetadata = {};
+                    bodyContent = contentToProcess; // Use original content
+                }
+                else {
+                    // Frontmatter is safe, merge with our metadata
+                    existingMetadata = parsed.data;
+                    bodyContent = parsed.content;
+                }
+            }
+        }
+        catch (error) {
+            // If gray-matter fails to parse, treat as content without frontmatter
+            logger.warn('Failed to parse potential frontmatter, treating as plain content', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+            // Continue with empty metadata and full content
+        }
+        // Merge metadata, with our metadata taking precedence for security
+        // This ensures critical fields like ID and type are always from our validated source
+        const mergedMetadata = {
+            ...existingMetadata, // Existing metadata first
+            ...this.metadata, // Our validated metadata overwrites
+            id: this.id, // Always use our ID
+            type: this.type, // Always use our type
+            version: this.version // Always use our version
+        };
+        // Validate the final merged metadata
+        const metadataYaml = yaml.dump(mergedMetadata, {
+            noRefs: true,
+            sortKeys: false,
+            lineWidth: -1
+        });
+        // Final security check on the complete metadata
+        const finalValidation = ContentValidator.validateAndSanitize(metadataYaml);
+        if (!finalValidation.isValid && finalValidation.severity === 'critical') {
+            // This shouldn't happen with our sanitized data, but log if it does
+            SecurityMonitor.logSecurityEvent({
+                type: 'UNICODE_VALIDATION_ERROR',
+                severity: 'MEDIUM',
+                source: 'PortfolioElementAdapter.serialize',
+                details: 'Final metadata validation failed after merge',
+                metadata: { elementId: this.id }
+            });
+            // Fall back to minimal safe metadata
+            const safeMetadata = {
+                id: this.id,
+                type: this.type,
+                version: this.version,
+                name: this.normalizeString(this.metadata.name || 'Untitled'),
+                description: this.normalizeString(this.metadata.description || '')
+            };
+            const safeFrontmatter = yaml.dump(safeMetadata, {
+                noRefs: true,
+                sortKeys: false,
+                lineWidth: -1
+            });
+            return `---\n${safeFrontmatter}---\n\n${bodyContent}`;
+        }
+        // Return validated and sanitized markdown with frontmatter
+        return `---\n${metadataYaml}---\n\n${bodyContent}`;
+    }
+    /**
+     * Deserialize from string (not implemented for adapter)
+     */
+    deserialize(data) {
+        throw new Error('Deserialization not supported for PortfolioElementAdapter');
+    }
+    /**
+     * Get element status
+     */
+    getStatus() {
+        return ElementStatus.INACTIVE;
+    }
+    /**
+     * Get the original portfolio element content
+     */
+    getContent() {
+        return this.portfolioElement.content;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PortfolioElementAdapter.js","sourceRoot":"","sources":["../../../src/tools/portfolio/PortfolioElementAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Adapter to convert simple portfolio elements to full IElement interface\n * This resolves type safety issues without complex type casting\n * \n * FIXES IMPLEMENTED (PR #503):\n * 1. TYPE SAFETY (Issue #497): Eliminates complex type casting with adapter pattern\n * 2. SECURITY FIX DMCP-SEC-004 (MEDIUM): Added Unicode normalization for all user input\n * 3. SECURITY FIX DMCP-SEC-006 (LOW): Added audit logging for element creation\n * 4. PERFORMANCE: Helper methods for efficient string normalization\n */\n\nimport { \n  IElement, \n  IElementMetadata, \n  ElementValidationResult, \n  ElementStatus,\n  ValidationError,\n  ValidationWarning\n} from '../../types/elements/IElement.js';\nimport { ElementType } from '../../portfolio/types.js';\nimport { PortfolioElement } from './submitToPortfolioTool.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\nimport { logger } from '../../utils/logger.js';\nimport * as yaml from 'js-yaml';\nimport matter from 'gray-matter';\nimport { ContentValidator } from '../../security/contentValidator.js';\n\n/**\n * Adapter class that wraps a simple PortfolioElement and implements IElement\n * This allows us to pass portfolio elements to methods expecting IElement\n * without complex type casting\n */\nexport class PortfolioElementAdapter implements IElement {\n  public readonly id: string;\n  public readonly type: ElementType;\n  public readonly version: string;\n  public readonly metadata: IElementMetadata;\n  private readonly portfolioElement: PortfolioElement;\n\n  constructor(element: PortfolioElement) {\n    // SECURITY FIX #2 (DMCP-SEC-004): Normalize and validate all user input\n    // Previously: User input was used directly without validation\n    // Now: All string inputs go through UnicodeValidator to prevent homograph attacks\n    const normalizedName = UnicodeValidator.normalize(element.metadata.name);\n    if (!normalizedName.isValid) {\n      // Log security event for invalid Unicode\n      SecurityMonitor.logSecurityEvent({\n        type: 'UNICODE_VALIDATION_ERROR',\n        severity: 'MEDIUM',\n        source: 'PortfolioElementAdapter.constructor',\n        details: `Invalid Unicode in element name: ${normalizedName.detectedIssues?.[0] || 'unknown'}`\n      });\n      logger.warn('Invalid Unicode detected in element name', {\n        issues: normalizedName.detectedIssues\n      });\n    }\n    \n    this.portfolioElement = element;\n    this.type = element.type;\n    this.version = element.metadata.version || '1.0.0';\n    \n    // Generate ID from type and normalized name\n    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');\n    const safeName = normalizedName.normalizedContent || element.metadata.name;\n    const nameSlug = safeName.toLowerCase().replace(/\\s+/g, '-');\n    this.id = `${element.type}_${nameSlug}_${timestamp}`;\n    \n    // Convert metadata to IElementMetadata format with normalized values\n    this.metadata = {\n      name: safeName,\n      description: this.normalizeString(element.metadata.description || ''),\n      author: this.normalizeString(element.metadata.author || ''),\n      version: element.metadata.version,\n      created: element.metadata.created,\n      modified: element.metadata.updated,\n      tags: []\n    };\n    \n    // SECURITY FIX #3 (DMCP-SEC-006): Log element creation for audit trail\n    // Previously: No audit logging for portfolio operations\n    // Now: Complete audit trail using SecurityMonitor.logSecurityEvent()\n    SecurityMonitor.logSecurityEvent({\n      type: 'ELEMENT_CREATED',\n      severity: 'LOW',\n      source: 'PortfolioElementAdapter.constructor',\n      details: `Created portfolio element adapter: ${this.id}`,\n      metadata: {\n        elementType: this.type,\n        elementId: this.id\n      }\n    });\n  }\n  \n  /**\n   * Helper to normalize string values safely\n   */\n  private normalizeString(value: string): string {\n    if (!value) return value;\n    const normalized = UnicodeValidator.normalize(value);\n    return normalized.normalizedContent || value;\n  }\n\n  /**\n   * Validate the element\n   */\n  validate(): ElementValidationResult {\n    const errors: ValidationError[] = [];\n    const warnings: ValidationWarning[] = [];\n\n    if (!this.metadata.name) {\n      errors.push({\n        field: 'name',\n        message: 'Element name is required'\n      });\n    }\n    \n    if (!this.portfolioElement.content) {\n      errors.push({\n        field: 'content',\n        message: 'Element content is required'\n      });\n    }\n\n    return {\n      valid: errors.length === 0,\n      errors: errors.length > 0 ? errors : undefined,\n      warnings: warnings.length > 0 ? warnings : undefined\n    };\n  }\n\n  /**\n   * Serialize the element to markdown with YAML frontmatter\n   * FIX: Changed from JSON to markdown format for GitHub portfolio compatibility\n   * SECURITY FIX #544: Parse and validate existing frontmatter instead of returning as-is\n   * SECURITY FIX #543: Use gray-matter for robust frontmatter detection\n   */\n  serialize(): string {\n    // SECURITY FIX #543: Use gray-matter for robust frontmatter detection\n    // This handles different line endings, whitespace variations, and malformed YAML\n    let contentToProcess = this.portfolioElement.content;\n    let existingMetadata: Record<string, any> = {};\n    let bodyContent = contentToProcess;\n    \n    // Try to parse existing frontmatter if present\n    try {\n      // gray-matter handles all edge cases:\n      // - Different line endings (\\n, \\r\\n)\n      // - Whitespace variations\n      // - Malformed YAML (returns empty data object)\n      // - Missing closing delimiter\n      const parsed = matter(contentToProcess);\n      \n      if (parsed.data && Object.keys(parsed.data).length > 0) {\n        // SECURITY FIX #544: Validate existing frontmatter instead of bypassing\n        logger.debug('Found existing frontmatter, validating before merge');\n        \n        // Validate the parsed frontmatter\n        const validationResult = ContentValidator.validateAndSanitize(\n          yaml.dump(parsed.data)\n        );\n        \n        if (!validationResult.isValid && validationResult.severity === 'critical') {\n          // Log security event for malicious frontmatter\n          SecurityMonitor.logSecurityEvent({\n            type: 'CONTENT_INJECTION_ATTEMPT',\n            severity: 'HIGH',\n            source: 'PortfolioElementAdapter.serialize',\n            details: `Critical security issues in frontmatter: ${validationResult.detectedPatterns?.join(', ')}`,\n            metadata: {\n              elementId: this.id,\n              elementType: this.type\n            }\n          });\n          \n          // Don't use the malicious frontmatter, create new\n          existingMetadata = {};\n          bodyContent = contentToProcess; // Use original content\n        } else {\n          // Frontmatter is safe, merge with our metadata\n          existingMetadata = parsed.data;\n          bodyContent = parsed.content;\n        }\n      }\n    } catch (error) {\n      // If gray-matter fails to parse, treat as content without frontmatter\n      logger.warn('Failed to parse potential frontmatter, treating as plain content', {\n        error: error instanceof Error ? error.message : String(error)\n      });\n      // Continue with empty metadata and full content\n    }\n    \n    // Merge metadata, with our metadata taking precedence for security\n    // This ensures critical fields like ID and type are always from our validated source\n    const mergedMetadata = {\n      ...existingMetadata, // Existing metadata first\n      ...this.metadata,    // Our validated metadata overwrites\n      id: this.id,         // Always use our ID\n      type: this.type,     // Always use our type\n      version: this.version // Always use our version\n    };\n    \n    // Validate the final merged metadata\n    const metadataYaml = yaml.dump(mergedMetadata, {\n      noRefs: true,\n      sortKeys: false,\n      lineWidth: -1\n    });\n    \n    // Final security check on the complete metadata\n    const finalValidation = ContentValidator.validateAndSanitize(metadataYaml);\n    \n    if (!finalValidation.isValid && finalValidation.severity === 'critical') {\n      // This shouldn't happen with our sanitized data, but log if it does\n      SecurityMonitor.logSecurityEvent({\n        type: 'UNICODE_VALIDATION_ERROR',\n        severity: 'MEDIUM',\n        source: 'PortfolioElementAdapter.serialize',\n        details: 'Final metadata validation failed after merge',\n        metadata: { elementId: this.id }\n      });\n      \n      // Fall back to minimal safe metadata\n      const safeMetadata = {\n        id: this.id,\n        type: this.type,\n        version: this.version,\n        name: this.normalizeString(this.metadata.name || 'Untitled'),\n        description: this.normalizeString(this.metadata.description || '')\n      };\n      \n      const safeFrontmatter = yaml.dump(safeMetadata, {\n        noRefs: true,\n        sortKeys: false,\n        lineWidth: -1\n      });\n      \n      return `---\\n${safeFrontmatter}---\\n\\n${bodyContent}`;\n    }\n    \n    // Return validated and sanitized markdown with frontmatter\n    return `---\\n${metadataYaml}---\\n\\n${bodyContent}`;\n  }\n\n  /**\n   * Deserialize from string (not implemented for adapter)\n   */\n  deserialize(data: string): void {\n    throw new Error('Deserialization not supported for PortfolioElementAdapter');\n  }\n\n  /**\n   * Get element status\n   */\n  getStatus(): ElementStatus {\n    return ElementStatus.INACTIVE;\n  }\n\n  /**\n   * Get the original portfolio element content\n   */\n  getContent(): string {\n    return this.portfolioElement.content;\n  }\n}"]}