@dollhousemcp/mcp-server 1.3.0

package/dist/test/src/security/securityMonitor.js

@@ -0,0 +1,108 @@
+/**
+ * Security Monitor for DollhouseMCP
+ *
+ * Centralized security event logging and monitoring system
+ * for tracking and alerting on security-related events.
+ */
+import { logger } from '../utils/logger.js';
+export class SecurityMonitor {
+    static eventCount = 0;
+    static events = [];
+    static MAX_EVENTS = 1000; // Keep last 1000 events in memory
+    /**
+     * Logs a security event
+     */
+    static logSecurityEvent(event) {
+        const logEntry = {
+            ...event,
+            timestamp: new Date().toISOString(),
+            id: `SEC-${Date.now()}-${++this.eventCount}`,
+        };
+        // Store in memory (circular buffer)
+        this.events.push(logEntry);
+        if (this.events.length > this.MAX_EVENTS) {
+            this.events.shift();
+        }
+        // In MCP servers, we cannot write to stderr/stdout as it breaks the JSON-RPC protocol
+        // Security events are stored in memory and can be retrieved via API
+        // Only send critical alerts via the proper channel
+        if (event.severity === 'CRITICAL') {
+            this.sendSecurityAlert(logEntry);
+        }
+    }
+    /**
+     * Sends security alerts for critical events
+     */
+    static sendSecurityAlert(event) {
+        // In a production environment, this would integrate with:
+        // - Slack webhooks
+        // - Email alerts
+        // - PagerDuty
+        // - Security Information and Event Management (SIEM) systems
+        // Log critical security alerts with structured data
+        // DO NOT use console.error in MCP servers as it breaks the JSON-RPC protocol
+        logger.error('🚨 CRITICAL SECURITY ALERT 🚨', {
+            type: event.type,
+            details: event.details,
+            timestamp: event.timestamp,
+            id: event.id
+        });
+        // If in production mode with proper config, send actual alerts
+        if (process.env.DOLLHOUSE_SECURITY_ALERTS === 'true') {
+            // TODO: Implement actual alert mechanisms
+        }
+    }
+    /**
+     * Gets recent security events for analysis
+     */
+    static getRecentEvents(count = 100) {
+        return this.events.slice(-count);
+    }
+    /**
+     * Gets events by severity
+     */
+    static getEventsBySeverity(severity) {
+        return this.events.filter(event => event.severity === severity);
+    }
+    /**
+     * Gets events by type
+     */
+    static getEventsByType(type) {
+        return this.events.filter(event => event.type === type);
+    }
+    /**
+     * Generates a security report
+     */
+    static generateSecurityReport() {
+        const eventsBySeverity = {
+            CRITICAL: 0,
+            HIGH: 0,
+            MEDIUM: 0,
+            LOW: 0,
+        };
+        const eventsByType = {};
+        for (const event of this.events) {
+            eventsBySeverity[event.severity]++;
+            eventsByType[event.type] = (eventsByType[event.type] || 0) + 1;
+        }
+        return {
+            totalEvents: this.events.length,
+            eventsBySeverity,
+            eventsByType,
+            recentCriticalEvents: this.getEventsBySeverity('CRITICAL').slice(-10),
+        };
+    }
+    /**
+     * Clears old events (for memory management)
+     */
+    static clearOldEvents(daysToKeep = 7) {
+        const cutoffDate = new Date();
+        cutoffDate.setDate(cutoffDate.getDate() - daysToKeep);
+        const cutoffTimestamp = cutoffDate.toISOString();
+        const index = this.events.findIndex(event => event.timestamp >= cutoffTimestamp);
+        if (index > 0) {
+            this.events.splice(0, index);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"securityMonitor.js","sourceRoot":"","sources":["../../../../src/security/securityMonitor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AA6B5C,MAAM,OAAO,eAAe;IAClB,MAAM,CAAC,UAAU,GAAG,CAAC,CAAC;IACtB,MAAM,CAAU,MAAM,GAAuB,EAAE,CAAC;IAChD,MAAM,CAAU,UAAU,GAAG,IAAI,CAAC,CAAC,kCAAkC;IAE7E;;OAEG;IACH,MAAM,CAAC,gBAAgB,CAAC,KAAoB;QAC1C,MAAM,QAAQ,GAAqB;YACjC,GAAG,KAAK;YACR,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACnC,EAAE,EAAE,OAAO,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE;SAC7C,CAAC;QAEF,oCAAoC;QACpC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC3B,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;YACzC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QACtB,CAAC;QAED,sFAAsF;QACtF,oEAAoE;QACpE,mDAAmD;QAEnD,IAAI,KAAK,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;YAClC,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QACnC,CAAC;IACH,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,iBAAiB,CAAC,KAAuB;QACtD,0DAA0D;QAC1D,mBAAmB;QACnB,iBAAiB;QACjB,cAAc;QACd,6DAA6D;QAE7D,oDAAoD;QACpD,6EAA6E;QAC7E,MAAM,CAAC,KAAK,CAAC,+BAA+B,EAAE;YAC5C,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,EAAE,EAAE,KAAK,CAAC,EAAE;SACb,CAAC,CAAC;QAEH,+DAA+D;QAC/D,IAAI,OAAO,CAAC,GAAG,CAAC,yBAAyB,KAAK,MAAM,EAAE,CAAC;YACrD,0CAA0C;QAC5C,CAAC;IACH,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,eAAe,CAAC,QAAgB,GAAG;QACxC,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC;IACnC,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,QAAmC;QAC5D,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC;IAClE,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,eAAe,CAAC,IAA2B;QAChD,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;IAC1D,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,sBAAsB;QAM3B,MAAM,gBAAgB,GAA2B;YAC/C,QAAQ,EAAE,CAAC;YACX,IAAI,EAAE,CAAC;YACP,MAAM,EAAE,CAAC;YACT,GAAG,EAAE,CAAC;SACP,CAAC;QAEF,MAAM,YAAY,GAA2B,EAAE,CAAC;QAEhD,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChC,gBAAgB,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;YACnC,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACjE,CAAC;QAED,OAAO;YACL,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM;YAC/B,gBAAgB;YAChB,YAAY;YACZ,oBAAoB,EAAE,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;SACtE,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,aAAqB,CAAC;QAC1C,MAAM,UAAU,GAAG,IAAI,IAAI,EAAE,CAAC;QAC9B,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,EAAE,GAAG,UAAU,CAAC,CAAC;QACtD,MAAM,eAAe,GAAG,UAAU,CAAC,WAAW,EAAE,CAAC;QAEjD,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,SAAS,IAAI,eAAe,CAAC,CAAC;QACjF,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YACd,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QAC/B,CAAC;IACH,CAAC","sourcesContent":["/**\n * Security Monitor for DollhouseMCP\n * \n * Centralized security event logging and monitoring system\n * for tracking and alerting on security-related events.\n */\n\nimport { logger } from '../utils/logger.js';\n\nexport interface SecurityEvent {\n  type: 'CONTENT_INJECTION_ATTEMPT' | 'YAML_INJECTION_ATTEMPT' | 'PATH_TRAVERSAL_ATTEMPT' | \n        'TOKEN_VALIDATION_FAILURE' | 'UPDATE_SECURITY_VIOLATION' | 'RATE_LIMIT_EXCEEDED' |\n        'YAML_PARSING_WARNING' | 'YAML_PARSE_SUCCESS' | 'TOKEN_VALIDATION_SUCCESS' |\n        'RATE_LIMIT_WARNING' | 'TOKEN_CACHE_CLEARED' | 'YAML_UNICODE_ATTACK' |\n        'UNICODE_DIRECTION_OVERRIDE' | 'UNICODE_MIXED_SCRIPT' | 'UNICODE_VALIDATION_ERROR' |\n        'CONTENT_SIZE_EXCEEDED' | 'INCLUDE_DEPTH_EXCEEDED' | 'TEMPLATE_RENDERED' | \n        'TEMPLATE_INCLUDE' | 'TEMPLATE_LOADED' | 'TEMPLATE_SAVED' | 'TEMPLATE_DELETED' |\n        'MEMORY_CREATED' | 'MEMORY_ADDED' | 'MEMORY_SEARCHED' | 'SENSITIVE_MEMORY_DELETED' |\n        'RETENTION_POLICY_ENFORCED' | 'MEMORY_CLEARED' | 'MEMORY_LOADED' | 'MEMORY_SAVED' |\n        'MEMORY_DELETED' | 'MEMORY_LOAD_FAILED' | 'MEMORY_SAVE_FAILED' | 'MEMORY_LIST_ITEM_FAILED' |\n        'MEMORY_IMPORT_FAILED' | 'MEMORY_DESERIALIZE_FAILED' | 'ELEMENT_CREATED' | 'ELEMENT_DELETED' |\n        'AGENT_DECISION' | 'RULE_ENGINE_CONFIG_UPDATE' | 'RULE_ENGINE_CONFIG_VALIDATION_ERROR' |\n        'GOAL_TEMPLATE_APPLIED' | 'GOAL_TEMPLATE_VALIDATION';\n  severity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';\n  source: string;\n  details: string;\n  userAgent?: string;\n  ip?: string;\n  additionalData?: Record<string, any>;\n}\n\nexport interface SecurityLogEntry extends SecurityEvent {\n  timestamp: string;\n  id: string;\n}\n\nexport class SecurityMonitor {\n  private static eventCount = 0;\n  private static readonly events: SecurityLogEntry[] = [];\n  private static readonly MAX_EVENTS = 1000; // Keep last 1000 events in memory\n\n  /**\n   * Logs a security event\n   */\n  static logSecurityEvent(event: SecurityEvent): void {\n    const logEntry: SecurityLogEntry = {\n      ...event,\n      timestamp: new Date().toISOString(),\n      id: `SEC-${Date.now()}-${++this.eventCount}`,\n    };\n\n    // Store in memory (circular buffer)\n    this.events.push(logEntry);\n    if (this.events.length > this.MAX_EVENTS) {\n      this.events.shift();\n    }\n\n    // In MCP servers, we cannot write to stderr/stdout as it breaks the JSON-RPC protocol\n    // Security events are stored in memory and can be retrieved via API\n    // Only send critical alerts via the proper channel\n    \n    if (event.severity === 'CRITICAL') {\n      this.sendSecurityAlert(logEntry);\n    }\n  }\n\n  /**\n   * Sends security alerts for critical events\n   */\n  private static sendSecurityAlert(event: SecurityLogEntry): void {\n    // In a production environment, this would integrate with:\n    // - Slack webhooks\n    // - Email alerts\n    // - PagerDuty\n    // - Security Information and Event Management (SIEM) systems\n    \n    // Log critical security alerts with structured data\n    // DO NOT use console.error in MCP servers as it breaks the JSON-RPC protocol\n    logger.error('🚨 CRITICAL SECURITY ALERT 🚨', {\n      type: event.type,\n      details: event.details,\n      timestamp: event.timestamp,\n      id: event.id\n    });\n    \n    // If in production mode with proper config, send actual alerts\n    if (process.env.DOLLHOUSE_SECURITY_ALERTS === 'true') {\n      // TODO: Implement actual alert mechanisms\n    }\n  }\n\n  /**\n   * Gets recent security events for analysis\n   */\n  static getRecentEvents(count: number = 100): SecurityLogEntry[] {\n    return this.events.slice(-count);\n  }\n\n  /**\n   * Gets events by severity\n   */\n  static getEventsBySeverity(severity: SecurityEvent['severity']): SecurityLogEntry[] {\n    return this.events.filter(event => event.severity === severity);\n  }\n\n  /**\n   * Gets events by type\n   */\n  static getEventsByType(type: SecurityEvent['type']): SecurityLogEntry[] {\n    return this.events.filter(event => event.type === type);\n  }\n\n  /**\n   * Generates a security report\n   */\n  static generateSecurityReport(): {\n    totalEvents: number;\n    eventsBySeverity: Record<string, number>;\n    eventsByType: Record<string, number>;\n    recentCriticalEvents: SecurityLogEntry[];\n  } {\n    const eventsBySeverity: Record<string, number> = {\n      CRITICAL: 0,\n      HIGH: 0,\n      MEDIUM: 0,\n      LOW: 0,\n    };\n\n    const eventsByType: Record<string, number> = {};\n\n    for (const event of this.events) {\n      eventsBySeverity[event.severity]++;\n      eventsByType[event.type] = (eventsByType[event.type] || 0) + 1;\n    }\n\n    return {\n      totalEvents: this.events.length,\n      eventsBySeverity,\n      eventsByType,\n      recentCriticalEvents: this.getEventsBySeverity('CRITICAL').slice(-10),\n    };\n  }\n\n  /**\n   * Clears old events (for memory management)\n   */\n  static clearOldEvents(daysToKeep: number = 7): void {\n    const cutoffDate = new Date();\n    cutoffDate.setDate(cutoffDate.getDate() - daysToKeep);\n    const cutoffTimestamp = cutoffDate.toISOString();\n\n    const index = this.events.findIndex(event => event.timestamp >= cutoffTimestamp);\n    if (index > 0) {\n      this.events.splice(0, index);\n    }\n  }\n}"]}

package/dist/test/src/security/tokenManager.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Secure GitHub token management and validation
+ */
+import { RateLimiter } from '../update/RateLimiter.js';
+export interface TokenScopes {
+    required: string[];
+    optional?: string[];
+}
+export interface TokenValidationResult {
+    isValid: boolean;
+    scopes?: string[];
+    rateLimit?: {
+        remaining: number;
+        resetTime: Date;
+    };
+    rateLimitExceeded?: boolean;
+    retryAfterMs?: number;
+    error?: string;
+}
+/**
+ * Secure GitHub token manager with validation and protection
+ */
+export declare class TokenManager {
+    private static readonly GITHUB_TOKEN_PATTERNS;
+    private static tokenValidationLimiter;
+    /**
+     * Get or create the token validation rate limiter
+     * Prevents brute force token validation attacks
+     */
+    private static getTokenValidationLimiter;
+    /**
+     * Create a rate limiter specifically for token validation
+     * Conservative limits to prevent abuse while allowing legitimate usage
+     */
+    static createTokenValidationLimiter(): RateLimiter;
+    /**
+     * Reset the token validation rate limiter
+     * Useful for testing or manual intervention
+     */
+    static resetTokenValidationLimiter(): void;
+    /**
+     * Validate GitHub token format
+     */
+    static validateTokenFormat(token: string): boolean;
+    /**
+     * Get GitHub token from environment with validation
+     */
+    static getGitHubToken(): string | null;
+    /**
+     * Redact token for safe logging
+     */
+    static redactToken(token: string): string;
+    /**
+     * Get token type from format
+     */
+    static getTokenType(token: string): string;
+    /**
+     * Get safe token prefix for logging
+     */
+    static getTokenPrefix(token: string): string;
+    /**
+     * Validate token scopes via GitHub API
+     */
+    static validateTokenScopes(token: string, requiredScopes: TokenScopes): Promise<TokenValidationResult>;
+    /**
+     * Create safe error message without token exposure
+     */
+    static createSafeErrorMessage(error: string, token?: string): string;
+    /**
+     * Get minimum required scopes for different operations
+     *
+     * NOTE: The 'marketplace' scope identifier is kept for backward compatibility
+     * with existing token validations. This is an internal scope name and does not
+     * affect user-facing functionality. (PR #280)
+     */
+    static getRequiredScopes(operation: 'read' | 'write' | 'marketplace' | 'collection' | 'gist'): TokenScopes;
+    /**
+     * Check if token has sufficient permissions for operation
+     *
+     * NOTE: The 'marketplace' operation type is kept for backward compatibility.
+     * This is called internally when accessing collection features. (PR #280)
+     */
+    static ensureTokenPermissions(operation: 'read' | 'write' | 'marketplace' | 'collection' | 'gist'): Promise<TokenValidationResult>;
+}
+//# sourceMappingURL=tokenManager.d.ts.map

package/dist/test/src/security/tokenManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenManager.d.ts","sourceRoot":"","sources":["../../../../src/security/tokenManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAGvD,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,CAAC,EAAE;QACV,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,IAAI,CAAC;KACjB,CAAC;IACF,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAK3C;IAGF,OAAO,CAAC,MAAM,CAAC,sBAAsB,CAA4B;IAEjE;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,yBAAyB;IAOxC;;;OAGG;IACH,MAAM,CAAC,4BAA4B,IAAI,WAAW;IAQlD;;;OAGG;IACH,MAAM,CAAC,2BAA2B,IAAI,IAAI;IAI1C;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAWlD;;OAEG;IACH,MAAM,CAAC,cAAc,IAAI,MAAM,GAAG,IAAI;IAwBtC;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAQzC;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAgB1C;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAO5C;;OAEG;WACU,mBAAmB,CAC9B,KAAK,EAAE,MAAM,EACb,cAAc,EAAE,WAAW,GAC1B,OAAO,CAAC,qBAAqB,CAAC;IA0HjC;;OAEG;IACH,MAAM,CAAC,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM;IAgBpE;;;;;;OAMG;IACH,MAAM,CAAC,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,GAAG,aAAa,GAAG,YAAY,GAAG,MAAM,GAAG,WAAW;IAkC1G;;;;;OAKG;WACU,sBAAsB,CACjC,SAAS,EAAE,MAAM,GAAG,OAAO,GAAG,aAAa,GAAG,YAAY,GAAG,MAAM,GAClE,OAAO,CAAC,qBAAqB,CAAC;CAalC"}

package/dist/test/src/security/tokenManager.js

@@ -0,0 +1,286 @@
+/**
+ * Secure GitHub token management and validation
+ */
+import { logger } from '../utils/logger.js';
+import { RateLimiter } from '../update/RateLimiter.js';
+import { SecurityError } from './errors.js';
+/**
+ * Secure GitHub token manager with validation and protection
+ */
+export class TokenManager {
+    static GITHUB_TOKEN_PATTERNS = {
+        PERSONAL_ACCESS_TOKEN: /^ghp_[A-Za-z0-9_]{36,}$/,
+        INSTALLATION_TOKEN: /^ghs_[A-Za-z0-9_]{36,}$/,
+        USER_ACCESS_TOKEN: /^ghu_[A-Za-z0-9_]{36,}$/,
+        REFRESH_TOKEN: /^ghr_[A-Za-z0-9_]{36,}$/
+    };
+    // Rate limiter for token validation operations - prevents brute force attacks
+    static tokenValidationLimiter = null;
+    /**
+     * Get or create the token validation rate limiter
+     * Prevents brute force token validation attacks
+     */
+    static getTokenValidationLimiter() {
+        if (!this.tokenValidationLimiter) {
+            this.tokenValidationLimiter = this.createTokenValidationLimiter();
+        }
+        return this.tokenValidationLimiter;
+    }
+    /**
+     * Create a rate limiter specifically for token validation
+     * Conservative limits to prevent abuse while allowing legitimate usage
+     */
+    static createTokenValidationLimiter() {
+        return new RateLimiter({
+            maxRequests: 10, // 10 validation attempts
+            windowMs: 60 * 60 * 1000, // per hour
+            minDelayMs: 5 * 1000 // 5 seconds minimum between attempts
+        });
+    }
+    /**
+     * Reset the token validation rate limiter
+     * Useful for testing or manual intervention
+     */
+    static resetTokenValidationLimiter() {
+        this.tokenValidationLimiter?.reset();
+    }
+    /**
+     * Validate GitHub token format
+     */
+    static validateTokenFormat(token) {
+        if (!token || typeof token !== 'string') {
+            return false;
+        }
+        // Check against all known GitHub token patterns
+        return Object.values(this.GITHUB_TOKEN_PATTERNS).some(pattern => pattern.test(token));
+    }
+    /**
+     * Get GitHub token from environment with validation
+     */
+    static getGitHubToken() {
+        const token = process.env.GITHUB_TOKEN;
+        if (!token) {
+            logger.debug('No GitHub token found in environment');
+            return null;
+        }
+        if (!this.validateTokenFormat(token)) {
+            logger.warn('Invalid GitHub token format detected', {
+                tokenPrefix: this.getTokenPrefix(token),
+                length: token.length
+            });
+            return null;
+        }
+        logger.debug('Valid GitHub token found', {
+            tokenType: this.getTokenType(token),
+            tokenPrefix: this.getTokenPrefix(token)
+        });
+        return token;
+    }
+    /**
+     * Redact token for safe logging
+     */
+    static redactToken(token) {
+        if (!token || token.length < 8) {
+            return '[REDACTED]';
+        }
+        return token.substring(0, 4) + '...' + token.substring(token.length - 4);
+    }
+    /**
+     * Get token type from format
+     */
+    static getTokenType(token) {
+        if (this.GITHUB_TOKEN_PATTERNS.PERSONAL_ACCESS_TOKEN.test(token)) {
+            return 'Personal Access Token';
+        }
+        if (this.GITHUB_TOKEN_PATTERNS.INSTALLATION_TOKEN.test(token)) {
+            return 'Installation Token';
+        }
+        if (this.GITHUB_TOKEN_PATTERNS.USER_ACCESS_TOKEN.test(token)) {
+            return 'User Access Token';
+        }
+        if (this.GITHUB_TOKEN_PATTERNS.REFRESH_TOKEN.test(token)) {
+            return 'Refresh Token';
+        }
+        return 'Unknown';
+    }
+    /**
+     * Get safe token prefix for logging
+     */
+    static getTokenPrefix(token) {
+        if (!token || token.length < 4) {
+            return '[INVALID]';
+        }
+        return token.substring(0, 4) + '...';
+    }
+    /**
+     * Validate token scopes via GitHub API
+     */
+    static async validateTokenScopes(token, requiredScopes) {
+        // Validate token format before consuming rate limit
+        if (!this.validateTokenFormat(token)) {
+            return {
+                isValid: false,
+                error: 'Invalid token format'
+            };
+        }
+        // Check rate limit before making API call
+        const rateLimiter = this.getTokenValidationLimiter();
+        const rateLimitStatus = rateLimiter.checkLimit();
+        if (!rateLimitStatus.allowed) {
+            logger.warn('Token validation rate limit exceeded', {
+                tokenPrefix: this.getTokenPrefix(token),
+                retryAfterMs: rateLimitStatus.retryAfterMs,
+                remainingTokens: rateLimitStatus.remainingTokens
+            });
+            throw new SecurityError(`Token validation rate limit exceeded. Please retry in ${Math.ceil((rateLimitStatus.retryAfterMs || 0) / 1000)} seconds.`, 'RATE_LIMIT_EXCEEDED');
+        }
+        try {
+            // Consume rate limit token for this validation attempt
+            rateLimiter.consumeToken();
+            // Make a test API call to check token validity and scopes
+            const response = await fetch('https://api.github.com/user', {
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'Accept': 'application/vnd.github.v3+json',
+                    'User-Agent': 'DollhouseMCP/1.0'
+                }
+            });
+            const rateLimitRemaining = parseInt(response.headers.get('x-ratelimit-remaining') || '0');
+            const rateLimitReset = parseInt(response.headers.get('x-ratelimit-reset') || '0');
+            if (!response.ok) {
+                const error = `GitHub API error: ${response.status} ${response.statusText}`;
+                logger.warn('Token validation failed', {
+                    status: response.status,
+                    tokenPrefix: this.getTokenPrefix(token)
+                });
+                return {
+                    isValid: false,
+                    error: error
+                };
+            }
+            // Extract scopes from response headers
+            const scopesHeader = response.headers.get('x-oauth-scopes') || '';
+            const tokenScopes = scopesHeader.split(',').map(s => s.trim()).filter(s => s);
+            // Check if required scopes are present
+            const hasRequiredScopes = requiredScopes.required.every(scope => tokenScopes.includes(scope));
+            if (!hasRequiredScopes) {
+                const missingScopes = requiredScopes.required.filter(scope => !tokenScopes.includes(scope));
+                logger.warn('Token missing required scopes', {
+                    tokenPrefix: this.getTokenPrefix(token),
+                    missingScopes: missingScopes,
+                    currentScopes: tokenScopes
+                });
+                return {
+                    isValid: false,
+                    scopes: tokenScopes,
+                    error: `Missing required scopes: ${missingScopes.join(', ')}`
+                };
+            }
+            logger.info('Token validation successful', {
+                tokenType: this.getTokenType(token),
+                tokenPrefix: this.getTokenPrefix(token),
+                scopes: tokenScopes,
+                rateLimitRemaining: rateLimitRemaining
+            });
+            return {
+                isValid: true,
+                scopes: tokenScopes,
+                rateLimit: {
+                    remaining: rateLimitRemaining,
+                    resetTime: new Date(rateLimitReset * 1000)
+                }
+            };
+        }
+        catch (error) {
+            // Handle SecurityError (including rate limit errors) separately
+            if (error instanceof SecurityError && error.code === 'RATE_LIMIT_EXCEEDED') {
+                const currentStatus = rateLimiter.checkLimit();
+                return {
+                    isValid: false,
+                    rateLimitExceeded: true,
+                    retryAfterMs: currentStatus.retryAfterMs,
+                    error: error.message
+                };
+            }
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            logger.error('Token validation error', {
+                error: errorMessage,
+                tokenPrefix: this.getTokenPrefix(token)
+            });
+            return {
+                isValid: false,
+                error: `Validation error: ${errorMessage}`
+            };
+        }
+    }
+    /**
+     * Create safe error message without token exposure
+     */
+    static createSafeErrorMessage(error, token) {
+        // Remove any potential token data from error messages
+        let safeMessage = error
+            .replace(/ghp_[A-Za-z0-9_]{36,}/g, '[REDACTED_PAT]')
+            .replace(/ghs_[A-Za-z0-9_]{36,}/g, '[REDACTED_INSTALL]')
+            .replace(/ghu_[A-Za-z0-9_]{36,}/g, '[REDACTED_USER]')
+            .replace(/ghr_[A-Za-z0-9_]{36,}/g, '[REDACTED_REFRESH]');
+        if (token) {
+            const tokenPrefix = this.getTokenPrefix(token);
+            safeMessage += ` (Token: ${tokenPrefix})`;
+        }
+        return safeMessage;
+    }
+    /**
+     * Get minimum required scopes for different operations
+     *
+     * NOTE: The 'marketplace' scope identifier is kept for backward compatibility
+     * with existing token validations. This is an internal scope name and does not
+     * affect user-facing functionality. (PR #280)
+     */
+    static getRequiredScopes(operation) {
+        switch (operation) {
+            case 'read':
+                return {
+                    required: ['repo'],
+                    optional: ['user:email']
+                };
+            case 'write':
+                return {
+                    required: ['repo'],
+                    optional: ['user:email']
+                };
+            case 'marketplace': // Internal scope name kept for compatibility (PR #280)
+            case 'collection': // New preferred name
+                return {
+                    required: ['repo'],
+                    optional: ['user:email']
+                };
+            case 'gist':
+                return {
+                    required: ['gist'],
+                    optional: ['user:email']
+                };
+            default:
+                return {
+                    required: ['repo']
+                };
+        }
+    }
+    /**
+     * Check if token has sufficient permissions for operation
+     *
+     * NOTE: The 'marketplace' operation type is kept for backward compatibility.
+     * This is called internally when accessing collection features. (PR #280)
+     */
+    static async ensureTokenPermissions(operation) {
+        const token = this.getGitHubToken();
+        if (!token) {
+            return {
+                isValid: false,
+                error: 'No GitHub token available'
+            };
+        }
+        const requiredScopes = this.getRequiredScopes(operation);
+        return this.validateTokenScopes(token, requiredScopes);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tokenManager.js","sourceRoot":"","sources":["../../../../src/security/tokenManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Secure GitHub token management and validation\n */\n\nimport { logger } from '../utils/logger.js';\nimport { RateLimiter } from '../update/RateLimiter.js';\nimport { SecurityError } from './errors.js';\n\nexport interface TokenScopes {\n  required: string[];\n  optional?: string[];\n}\n\nexport interface TokenValidationResult {\n  isValid: boolean;\n  scopes?: string[];\n  rateLimit?: {\n    remaining: number;\n    resetTime: Date;\n  };\n  rateLimitExceeded?: boolean;\n  retryAfterMs?: number;\n  error?: string;\n}\n\n/**\n * Secure GitHub token manager with validation and protection\n */\nexport class TokenManager {\n  private static readonly GITHUB_TOKEN_PATTERNS = {\n    PERSONAL_ACCESS_TOKEN: /^ghp_[A-Za-z0-9_]{36,}$/,\n    INSTALLATION_TOKEN: /^ghs_[A-Za-z0-9_]{36,}$/,\n    USER_ACCESS_TOKEN: /^ghu_[A-Za-z0-9_]{36,}$/,\n    REFRESH_TOKEN: /^ghr_[A-Za-z0-9_]{36,}$/\n  };\n\n  // Rate limiter for token validation operations - prevents brute force attacks\n  private static tokenValidationLimiter: RateLimiter | null = null;\n\n  /**\n   * Get or create the token validation rate limiter\n   * Prevents brute force token validation attacks\n   */\n  private static getTokenValidationLimiter(): RateLimiter {\n    if (!this.tokenValidationLimiter) {\n      this.tokenValidationLimiter = this.createTokenValidationLimiter();\n    }\n    return this.tokenValidationLimiter;\n  }\n\n  /**\n   * Create a rate limiter specifically for token validation\n   * Conservative limits to prevent abuse while allowing legitimate usage\n   */\n  static createTokenValidationLimiter(): RateLimiter {\n    return new RateLimiter({\n      maxRequests: 10,          // 10 validation attempts\n      windowMs: 60 * 60 * 1000, // per hour\n      minDelayMs: 5 * 1000      // 5 seconds minimum between attempts\n    });\n  }\n\n  /**\n   * Reset the token validation rate limiter\n   * Useful for testing or manual intervention\n   */\n  static resetTokenValidationLimiter(): void {\n    this.tokenValidationLimiter?.reset();\n  }\n\n  /**\n   * Validate GitHub token format\n   */\n  static validateTokenFormat(token: string): boolean {\n    if (!token || typeof token !== 'string') {\n      return false;\n    }\n\n    // Check against all known GitHub token patterns\n    return Object.values(this.GITHUB_TOKEN_PATTERNS).some(pattern => \n      pattern.test(token)\n    );\n  }\n\n  /**\n   * Get GitHub token from environment with validation\n   */\n  static getGitHubToken(): string | null {\n    const token = process.env.GITHUB_TOKEN;\n    \n    if (!token) {\n      logger.debug('No GitHub token found in environment');\n      return null;\n    }\n\n    if (!this.validateTokenFormat(token)) {\n      logger.warn('Invalid GitHub token format detected', {\n        tokenPrefix: this.getTokenPrefix(token),\n        length: token.length\n      });\n      return null;\n    }\n\n    logger.debug('Valid GitHub token found', {\n      tokenType: this.getTokenType(token),\n      tokenPrefix: this.getTokenPrefix(token)\n    });\n\n    return token;\n  }\n\n  /**\n   * Redact token for safe logging\n   */\n  static redactToken(token: string): string {\n    if (!token || token.length < 8) {\n      return '[REDACTED]';\n    }\n    \n    return token.substring(0, 4) + '...' + token.substring(token.length - 4);\n  }\n\n  /**\n   * Get token type from format\n   */\n  static getTokenType(token: string): string {\n    if (this.GITHUB_TOKEN_PATTERNS.PERSONAL_ACCESS_TOKEN.test(token)) {\n      return 'Personal Access Token';\n    }\n    if (this.GITHUB_TOKEN_PATTERNS.INSTALLATION_TOKEN.test(token)) {\n      return 'Installation Token';\n    }\n    if (this.GITHUB_TOKEN_PATTERNS.USER_ACCESS_TOKEN.test(token)) {\n      return 'User Access Token';\n    }\n    if (this.GITHUB_TOKEN_PATTERNS.REFRESH_TOKEN.test(token)) {\n      return 'Refresh Token';\n    }\n    return 'Unknown';\n  }\n\n  /**\n   * Get safe token prefix for logging\n   */\n  static getTokenPrefix(token: string): string {\n    if (!token || token.length < 4) {\n      return '[INVALID]';\n    }\n    return token.substring(0, 4) + '...';\n  }\n\n  /**\n   * Validate token scopes via GitHub API\n   */\n  static async validateTokenScopes(\n    token: string, \n    requiredScopes: TokenScopes\n  ): Promise<TokenValidationResult> {\n    // Validate token format before consuming rate limit\n    if (!this.validateTokenFormat(token)) {\n      return {\n        isValid: false,\n        error: 'Invalid token format'\n      };\n    }\n\n    // Check rate limit before making API call\n    const rateLimiter = this.getTokenValidationLimiter();\n    const rateLimitStatus = rateLimiter.checkLimit();\n\n    if (!rateLimitStatus.allowed) {\n      logger.warn('Token validation rate limit exceeded', {\n        tokenPrefix: this.getTokenPrefix(token),\n        retryAfterMs: rateLimitStatus.retryAfterMs,\n        remainingTokens: rateLimitStatus.remainingTokens\n      });\n\n      throw new SecurityError(\n        `Token validation rate limit exceeded. Please retry in ${Math.ceil((rateLimitStatus.retryAfterMs || 0) / 1000)} seconds.`,\n        'RATE_LIMIT_EXCEEDED'\n      );\n    }\n\n    try {\n      // Consume rate limit token for this validation attempt\n      rateLimiter.consumeToken();\n      // Make a test API call to check token validity and scopes\n      const response = await fetch('https://api.github.com/user', {\n        headers: {\n          'Authorization': `Bearer ${token}`,\n          'Accept': 'application/vnd.github.v3+json',\n          'User-Agent': 'DollhouseMCP/1.0'\n        }\n      });\n\n      const rateLimitRemaining = parseInt(response.headers.get('x-ratelimit-remaining') || '0');\n      const rateLimitReset = parseInt(response.headers.get('x-ratelimit-reset') || '0');\n\n      if (!response.ok) {\n        const error = `GitHub API error: ${response.status} ${response.statusText}`;\n        logger.warn('Token validation failed', {\n          status: response.status,\n          tokenPrefix: this.getTokenPrefix(token)\n        });\n        \n        return {\n          isValid: false,\n          error: error\n        };\n      }\n\n      // Extract scopes from response headers\n      const scopesHeader = response.headers.get('x-oauth-scopes') || '';\n      const tokenScopes = scopesHeader.split(',').map(s => s.trim()).filter(s => s);\n\n      // Check if required scopes are present\n      const hasRequiredScopes = requiredScopes.required.every(scope => \n        tokenScopes.includes(scope)\n      );\n\n      if (!hasRequiredScopes) {\n        const missingScopes = requiredScopes.required.filter(scope => \n          !tokenScopes.includes(scope)\n        );\n        \n        logger.warn('Token missing required scopes', {\n          tokenPrefix: this.getTokenPrefix(token),\n          missingScopes: missingScopes,\n          currentScopes: tokenScopes\n        });\n\n        return {\n          isValid: false,\n          scopes: tokenScopes,\n          error: `Missing required scopes: ${missingScopes.join(', ')}`\n        };\n      }\n\n      logger.info('Token validation successful', {\n        tokenType: this.getTokenType(token),\n        tokenPrefix: this.getTokenPrefix(token),\n        scopes: tokenScopes,\n        rateLimitRemaining: rateLimitRemaining\n      });\n\n      return {\n        isValid: true,\n        scopes: tokenScopes,\n        rateLimit: {\n          remaining: rateLimitRemaining,\n          resetTime: new Date(rateLimitReset * 1000)\n        }\n      };\n\n    } catch (error) {\n      // Handle SecurityError (including rate limit errors) separately\n      if (error instanceof SecurityError && error.code === 'RATE_LIMIT_EXCEEDED') {\n        const currentStatus = rateLimiter.checkLimit();\n        return {\n          isValid: false,\n          rateLimitExceeded: true,\n          retryAfterMs: currentStatus.retryAfterMs,\n          error: error.message\n        };\n      }\n\n      const errorMessage = error instanceof Error ? error.message : 'Unknown error';\n      logger.error('Token validation error', {\n        error: errorMessage,\n        tokenPrefix: this.getTokenPrefix(token)\n      });\n\n      return {\n        isValid: false,\n        error: `Validation error: ${errorMessage}`\n      };\n    }\n  }\n\n  /**\n   * Create safe error message without token exposure\n   */\n  static createSafeErrorMessage(error: string, token?: string): string {\n    // Remove any potential token data from error messages\n    let safeMessage = error\n      .replace(/ghp_[A-Za-z0-9_]{36,}/g, '[REDACTED_PAT]')\n      .replace(/ghs_[A-Za-z0-9_]{36,}/g, '[REDACTED_INSTALL]')\n      .replace(/ghu_[A-Za-z0-9_]{36,}/g, '[REDACTED_USER]')\n      .replace(/ghr_[A-Za-z0-9_]{36,}/g, '[REDACTED_REFRESH]');\n\n    if (token) {\n      const tokenPrefix = this.getTokenPrefix(token);\n      safeMessage += ` (Token: ${tokenPrefix})`;\n    }\n\n    return safeMessage;\n  }\n\n  /**\n   * Get minimum required scopes for different operations\n   * \n   * NOTE: The 'marketplace' scope identifier is kept for backward compatibility\n   * with existing token validations. This is an internal scope name and does not\n   * affect user-facing functionality. (PR #280)\n   */\n  static getRequiredScopes(operation: 'read' | 'write' | 'marketplace' | 'collection' | 'gist'): TokenScopes {\n    switch (operation) {\n      case 'read':\n        return {\n          required: ['repo'],\n          optional: ['user:email']\n        };\n      \n      case 'write':\n        return {\n          required: ['repo'],\n          optional: ['user:email']\n        };\n      \n      case 'marketplace': // Internal scope name kept for compatibility (PR #280)\n      case 'collection': // New preferred name\n        return {\n          required: ['repo'],\n          optional: ['user:email']\n        };\n      \n      case 'gist':\n        return {\n          required: ['gist'],\n          optional: ['user:email']\n        };\n      \n      default:\n        return {\n          required: ['repo']\n        };\n    }\n  }\n\n  /**\n   * Check if token has sufficient permissions for operation\n   * \n   * NOTE: The 'marketplace' operation type is kept for backward compatibility.\n   * This is called internally when accessing collection features. (PR #280)\n   */\n  static async ensureTokenPermissions(\n    operation: 'read' | 'write' | 'marketplace' | 'collection' | 'gist'\n  ): Promise<TokenValidationResult> {\n    const token = this.getGitHubToken();\n    \n    if (!token) {\n      return {\n        isValid: false,\n        error: 'No GitHub token available'\n      };\n    }\n\n    const requiredScopes = this.getRequiredScopes(operation);\n    return this.validateTokenScopes(token, requiredScopes);\n  }\n}"]}

package/dist/test/src/security/validators/unicodeValidator.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Unicode Validator for DollhouseMCP
+ *
+ * Prevents Unicode-based bypass attacks including:
+ * - Homograph attacks (visually similar characters)
+ * - Direction override attacks (RLO/LRO)
+ * - Mixed script attacks
+ * - Zero-width character injection
+ * - Unicode normalization bypasses
+ *
+ * Security: SEC-001 - Unicode attack prevention
+ */
+export interface UnicodeValidationResult {
+    isValid: boolean;
+    normalizedContent: string;
+    detectedIssues?: string[];
+    severity?: 'low' | 'medium' | 'high' | 'critical';
+}
+export declare class UnicodeValidator {
+    /**
+     * Unicode attack patterns and confusable characters
+     */
+    /**
+     * Direction override characters that can hide or reverse text display
+     * @see https://unicode.org/reports/tr9/#Directional_Formatting_Characters
+     * U+202A-U+202E: Left/Right embedding and override marks (LRE, RLE, PDF, LRO, RLO)
+     * U+2066-U+2069: Isolate formatting characters (LRI, RLI, FSI, PDI)
+     */
+    private static readonly DIRECTION_OVERRIDE_CHARS;
+    /**
+     * Zero-width and invisible formatting characters often used to hide payloads
+     * U+200B-U+200F: Zero-width spaces and directional marks
+     * U+2028-U+202F: Line/paragraph separators and formatting characters
+     * U+FEFF: Zero-width no-break space (Byte Order Mark)
+     */
+    private static readonly ZERO_WIDTH_CHARS;
+    /**
+     * Non-printable control characters that should not appear in normal text
+     * U+0000-U+0008, U+000B-U+000C, U+000E-U+001F: C0 control codes (except TAB, LF, CR)
+     * U+007F-U+009F: Delete and C1 control codes
+     * U+FFFE-U+FFFF: Non-characters that should never appear in valid text
+     */
+    private static readonly NON_PRINTABLE_CHARS;
+    /**
+     * Common homograph/confusable character mappings
+     * Maps visually similar Unicode characters to their ASCII equivalents
+     */
+    private static readonly CONFUSABLE_MAPPINGS;
+    /**
+     * Script mixing detection patterns
+     * Detects suspicious mixing of different Unicode scripts
+     */
+    private static readonly SCRIPT_PATTERNS;
+    /**
+     * Normalize Unicode content to prevent bypass attacks
+     */
+    static normalize(content: string): UnicodeValidationResult;
+    /**
+     * Detect suspicious Unicode patterns that might indicate attacks
+     */
+    private static detectSuspiciousPatterns;
+    /**
+     * Replace confusable Unicode characters with ASCII equivalents
+     */
+    private static replaceConfusables;
+    /**
+     * Detect suspicious mixing of different Unicode scripts
+     */
+    private static detectMixedScripts;
+    /**
+     * Escalate severity level (higher severity takes precedence)
+     */
+    private static escalateSeverity;
+    /**
+     * Escape special regex characters for safe replacement
+     */
+    private static escapeRegex;
+    /**
+     * Check if content contains potentially dangerous Unicode patterns
+     */
+    static containsDangerousUnicode(content: string): boolean;
+    /**
+     * Check if content has excessive Unicode escape sequences
+     * Prevents null pointer exception by safely checking match results
+     */
+    private static hasExcessiveUnicodeEscapes;
+    /**
+     * Safely check for malformed surrogate pairs without ReDoS vulnerability
+     * Uses character-by-character validation instead of complex regex
+     */
+    private static hasMalformedSurrogates;
+    /**
+     * Get safe preview of Unicode content for logging
+     */
+    static getSafePreview(content: string, maxLength?: number): string;
+}
+//# sourceMappingURL=unicodeValidator.d.ts.map

package/dist/test/src/security/validators/unicodeValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unicodeValidator.d.ts","sourceRoot":"","sources":["../../../../../src/security/validators/unicodeValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,QAAQ,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;CACnD;AAED,qBAAa,gBAAgB;IAC3B;;OAEG;IAEH;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,wBAAwB,CAAmC;IAEnF;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAyC;IAEjF;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAwE;IAEnH;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CA2BxC;IAEH;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAOrC;IAEF;;OAEG;IACH,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,uBAAuB;IAiG1D;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,wBAAwB;IA2CvC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAcjC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAoBjC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAW/B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,WAAW;IAI1B;;OAEG;IACH,MAAM,CAAC,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAQzD;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,0BAA0B;IAKzC;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAwBrC;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,GAAE,MAAY,GAAG,MAAM;CAWxE"}