@dollhousemcp/mcp-server 1.8.0 → 1.9.0

package/dist/security/securityMonitor.js

@@ -105,4 +105,4 @@ export class SecurityMonitor {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"securityMonitor.js","sourceRoot":"","sources":["../../src/security/securityMonitor.ts"],"names":[],"mappings":"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","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        'PATH_VALIDATION_SUCCESS' | 'RATE_LIMIT_WARNING' | 'TOKEN_CACHE_CLEARED' | \n        'YAML_UNICODE_ATTACK' | 'UNICODE_DIRECTION_OVERRIDE' | 'UNICODE_MIXED_SCRIPT' | \n        'UNICODE_VALIDATION_ERROR' | 'CONTENT_SIZE_EXCEEDED' | 'INCLUDE_DEPTH_EXCEEDED' | \n        'TEMPLATE_RENDERED' | 'TEMPLATE_INCLUDE' | 'TEMPLATE_LOADED' | 'TEMPLATE_SAVED' | \n        'TEMPLATE_DELETED' | 'MEMORY_CREATED' | 'MEMORY_ADDED' | 'MEMORY_SEARCHED' | \n        'SENSITIVE_MEMORY_DELETED' | 'RETENTION_POLICY_ENFORCED' | 'MEMORY_CLEARED' | \n        'MEMORY_LOADED' | 'MEMORY_SAVED' | 'MEMORY_DELETED' | 'MEMORY_LOAD_FAILED' | \n        'MEMORY_SAVE_FAILED' | 'MEMORY_LIST_ITEM_FAILED' | 'MEMORY_IMPORT_FAILED' | \n        'MEMORY_DESERIALIZE_FAILED' | 'ELEMENT_CREATED' | 'ELEMENT_DELETED' | 'AGENT_DECISION' | \n        'RULE_ENGINE_CONFIG_UPDATE' | 'RULE_ENGINE_CONFIG_VALIDATION_ERROR' |\n        'GOAL_TEMPLATE_APPLIED' | 'GOAL_TEMPLATE_VALIDATION' |\n        'ENSEMBLE_CIRCULAR_DEPENDENCY' | 'ENSEMBLE_RESOURCE_LIMIT_EXCEEDED' | \n        'ENSEMBLE_ACTIVATION_TIMEOUT' | 'ENSEMBLE_SUSPICIOUS_CONDITION' |\n        'ENSEMBLE_NESTED_DEPTH_EXCEEDED' | 'ENSEMBLE_CONTEXT_SIZE_EXCEEDED' |\n        'ENSEMBLE_SAVED' | 'ENSEMBLE_IMPORTED' | 'ENSEMBLE_DELETED' |\n        'PORTFOLIO_INITIALIZATION' | 'PORTFOLIO_POPULATED' | 'FILE_COPIED' | 'DIRECTORY_MIGRATION' |\n        'PORTFOLIO_CACHE_INVALIDATION' | 'PORTFOLIO_FETCH_SUCCESS' | 'TEST_DATA_BLOCKED' |\n        'TEST_PATH_SECURITY_RISK' | 'TEST_PRODUCTION_ACCESS_BLOCKED' | 'TEST_PATH_INVALID' |\n        'TEST_ENVIRONMENT_PRODUCTION_PATH' | 'TEST_ENVIRONMENT_DEPRECATED_VAR' | 'TOOL_CACHE_INVALIDATED';\n  severity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';\n  source: string;\n  details: string;\n  userAgent?: string;\n  ip?: string;\n  additionalData?: Record<string, any>;\n  metadata?: 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}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"securityMonitor.js","sourceRoot":"","sources":["../../src/security/securityMonitor.ts"],"names":[],"mappings":"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","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        'PATH_VALIDATION_SUCCESS' | 'RATE_LIMIT_WARNING' | 'TOKEN_CACHE_CLEARED' | \n        'YAML_UNICODE_ATTACK' | 'UNICODE_DIRECTION_OVERRIDE' | 'UNICODE_MIXED_SCRIPT' | \n        'UNICODE_VALIDATION_ERROR' | 'CONTENT_SIZE_EXCEEDED' | 'INCLUDE_DEPTH_EXCEEDED' | \n        'TEMPLATE_RENDERED' | 'TEMPLATE_INCLUDE' | 'TEMPLATE_LOADED' | 'TEMPLATE_SAVED' | \n        'TEMPLATE_DELETED' | 'MEMORY_CREATED' | 'MEMORY_ADDED' | 'MEMORY_SEARCHED' | \n        'SENSITIVE_MEMORY_DELETED' | 'RETENTION_POLICY_ENFORCED' | 'MEMORY_CLEARED' | \n        'MEMORY_LOADED' | 'MEMORY_SAVED' | 'MEMORY_DELETED' | 'MEMORY_LOAD_FAILED' |\n        'MEMORY_SAVE_FAILED' | 'MEMORY_LIST_ITEM_FAILED' | 'MEMORY_IMPORT_FAILED' |\n        'MEMORY_DESERIALIZE_FAILED' | 'MEMORY_INTEGRITY_VIOLATION' | 'MEMORY_UNICODE_VALIDATION_FAILED' |\n        'MEMORY_DUPLICATE_DETECTED' | 'ELEMENT_CREATED' | 'ELEMENT_DELETED' | 'AGENT_DECISION' | \n        'RULE_ENGINE_CONFIG_UPDATE' | 'RULE_ENGINE_CONFIG_VALIDATION_ERROR' |\n        'GOAL_TEMPLATE_APPLIED' | 'GOAL_TEMPLATE_VALIDATION' |\n        'ENSEMBLE_CIRCULAR_DEPENDENCY' | 'ENSEMBLE_RESOURCE_LIMIT_EXCEEDED' | \n        'ENSEMBLE_ACTIVATION_TIMEOUT' | 'ENSEMBLE_SUSPICIOUS_CONDITION' |\n        'ENSEMBLE_NESTED_DEPTH_EXCEEDED' | 'ENSEMBLE_CONTEXT_SIZE_EXCEEDED' |\n        'ENSEMBLE_SAVED' | 'ENSEMBLE_IMPORTED' | 'ENSEMBLE_DELETED' |\n        'PORTFOLIO_INITIALIZATION' | 'PORTFOLIO_POPULATED' | 'FILE_COPIED' | 'DIRECTORY_MIGRATION' |\n        'PORTFOLIO_CACHE_INVALIDATION' | 'PORTFOLIO_FETCH_SUCCESS' | 'TEST_DATA_BLOCKED' |\n        'TEST_PATH_SECURITY_RISK' | 'TEST_PRODUCTION_ACCESS_BLOCKED' | 'TEST_PATH_INVALID' |\n        'TEST_ENVIRONMENT_PRODUCTION_PATH' | 'TEST_ENVIRONMENT_DEPRECATED_VAR' | 'TOOL_CACHE_INVALIDATED';\n  severity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';\n  source: string;\n  details: string;\n  userAgent?: string;\n  ip?: string;\n  additionalData?: Record<string, any>;\n  metadata?: 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/tools/getWelcomeMessage.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Get Welcome Message Tool
+ *
+ * A dedicated MCP tool that returns the welcome message
+ * This gives us more control over how the message is presented
+ */
+export interface GetWelcomeMessageOptions {
+    format?: 'text' | 'markdown' | 'raw';
+    skipCheck?: boolean;
+}
+export declare class GetWelcomeMessageTool {
+    private configManager;
+    constructor();
+    /**
+     * Get the welcome message directly as a tool response
+     * This bypasses the response wrapping and gives us full control
+     */
+    execute(options?: GetWelcomeMessageOptions): Promise<any>;
+    /**
+     * Tool definition for MCP
+     */
+    static get definition(): {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                format: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                skipCheck: {
+                    type: string;
+                    description: string;
+                };
+            };
+        };
+    };
+}
+//# sourceMappingURL=getWelcomeMessage.d.ts.map

package/dist/tools/getWelcomeMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getWelcomeMessage.d.ts","sourceRoot":"","sources":["../../src/tools/getWelcomeMessage.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,WAAW,wBAAwB;IACvC,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,KAAK,CAAC;IACrC,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,qBAAa,qBAAqB;IAChC,OAAO,CAAC,aAAa,CAAgB;;IAMrC;;;OAGG;IACG,OAAO,CAAC,OAAO,GAAE,wBAA6B,GAAG,OAAO,CAAC,GAAG,CAAC;IAsEnE;;OAEG;IACH,MAAM,KAAK,UAAU;;;;;;;;;;;;;;;;;MAmBpB;CACF"}

package/dist/tools/getWelcomeMessage.js

@@ -0,0 +1,109 @@
+/**
+ * Get Welcome Message Tool
+ *
+ * A dedicated MCP tool that returns the welcome message
+ * This gives us more control over how the message is presented
+ */
+import { ConfigManager } from '../config/ConfigManager.js';
+export class GetWelcomeMessageTool {
+    configManager;
+    constructor() {
+        this.configManager = ConfigManager.getInstance();
+    }
+    /**
+     * Get the welcome message directly as a tool response
+     * This bypasses the response wrapping and gives us full control
+     */
+    async execute(options = {}) {
+        await this.configManager.initialize();
+        const config = this.configManager.getConfig();
+        // Check if we should show the welcome message
+        if (!options.skipCheck) {
+            if (config.wizard?.completed || config.wizard?.dismissed) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: "Welcome back to DollhouseMCP! The wizard has already been completed. Use 'Open configuration wizard' if you want to reconfigure."
+                        }]
+                };
+            }
+        }
+        const welcomeMessage = `🎨 **Welcome to DollhouseMCP!**
+
+Hi there! I see this is your first time here. DollhouseMCP helps you create powerful customization elements for your AI assistant - and it's easier than you might think!
+
+**What can you do with DollhouseMCP?**
+
+🎭 **Personas** - Change your AI's personality (make it funny, professional, creative, or anything you imagine)
+💡 **Skills** - Give your AI new abilities like taking meeting notes, reviewing code, or organizing your thoughts
+📝 **Templates** - Create reusable formats for emails, documentation, resumes, and more
+🤖 **Agents** - Build smart assistants that handle specific tasks automatically
+✨ **And more!** - Just describe what you want, and DollhouseMCP will help you create it
+
+The best part? Everything you create is saved and persistent. Your custom tools and assistants will be there whenever you need them. You can modify them anytime just by asking!
+
+**Need ideas?** Just ask "What would be the best way to..." and I'll help you figure out the perfect solution.
+
+**Ready to get started?** I'll help you:
+- Choose a username (this tags your creations so you can find them later - or stay anonymous, that's totally fine!)
+- Set up your workspace for saving all your customizations
+- Browse examples to spark your creativity
+- Create your first customization element
+
+Just say:
+- "Yes" or "Let's get started" → I'll guide you through setup
+- "Skip for now" → You can set up later when you're ready
+- "I'll stay anonymous" → Perfect! You can use everything without signing in
+
+**What's a username for?** It simply tags your creations (like "created by: you") so you can find them easily. Staying anonymous means your creations are tagged with a fun random ID instead (like "created by: clever-fox"). Either way, all your work is saved locally on your computer!
+
+Don't worry - this only takes a minute, and you can change any settings later! 🌟`;
+        // Return the message in the requested format
+        if (options.format === 'raw') {
+            // Just the text, no formatting
+            return welcomeMessage;
+        }
+        else if (options.format === 'markdown') {
+            // Return as markdown code block
+            return {
+                content: [{
+                        type: "text",
+                        text: "```markdown\n" + welcomeMessage + "\n```"
+                    }]
+            };
+        }
+        else {
+            // Default: Return as clean text with instruction
+            return {
+                content: [{
+                        type: "text",
+                        text: welcomeMessage
+                    }]
+            };
+        }
+    }
+    /**
+     * Tool definition for MCP
+     */
+    static get definition() {
+        return {
+            name: "dollhouse_welcome",
+            description: "Get the DollhouseMCP welcome message for first-time users",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    format: {
+                        type: "string",
+                        enum: ["text", "markdown", "raw"],
+                        description: "Format for the welcome message (default: text)"
+                    },
+                    skipCheck: {
+                        type: "boolean",
+                        description: "Skip checking if wizard was already completed (default: false)"
+                    }
+                }
+            }
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"getWelcomeMessage.js","sourceRoot":"","sources":["../../src/tools/getWelcomeMessage.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAO3D,MAAM,OAAO,qBAAqB;IACxB,aAAa,CAAgB;IAErC;QACE,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC,WAAW,EAAE,CAAC;IACnD,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,OAAO,CAAC,UAAoC,EAAE;QAClD,MAAM,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,CAAC;QACtC,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,CAAC;QAE9C,8CAA8C;QAC9C,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC;YACvB,IAAI,MAAM,CAAC,MAAM,EAAE,SAAS,IAAI,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC;gBACzD,OAAO;oBACL,OAAO,EAAE,CAAC;4BACR,IAAI,EAAE,MAAM;4BACZ,IAAI,EAAE,kIAAkI;yBACzI,CAAC;iBACH,CAAC;YACJ,CAAC;QACH,CAAC;QAED,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kFA6BuD,CAAC;QAE/E,6CAA6C;QAC7C,IAAI,OAAO,CAAC,MAAM,KAAK,KAAK,EAAE,CAAC;YAC7B,+BAA+B;YAC/B,OAAO,cAAc,CAAC;QACxB,CAAC;aAAM,IAAI,OAAO,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YACzC,gCAAgC;YAChC,OAAO;gBACL,OAAO,EAAE,CAAC;wBACR,IAAI,EAAE,MAAM;wBACZ,IAAI,EAAE,eAAe,GAAG,cAAc,GAAG,OAAO;qBACjD,CAAC;aACH,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,iDAAiD;YACjD,OAAO;gBACL,OAAO,EAAE,CAAC;wBACR,IAAI,EAAE,MAAM;wBACZ,IAAI,EAAE,cAAc;qBACrB,CAAC;aACH,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;OAEG;IACH,MAAM,KAAK,UAAU;QACnB,OAAO;YACL,IAAI,EAAE,mBAAmB;YACzB,WAAW,EAAE,2DAA2D;YACxE,WAAW,EAAE;gBACX,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,MAAM,EAAE;wBACN,IAAI,EAAE,QAAQ;wBACd,IAAI,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,CAAC;wBACjC,WAAW,EAAE,gDAAgD;qBAC9D;oBACD,SAAS,EAAE;wBACT,IAAI,EAAE,SAAS;wBACf,WAAW,EAAE,gEAAgE;qBAC9E;iBACF;aACF;SACF,CAAC;IACJ,CAAC;CACF","sourcesContent":["/**\n * Get Welcome Message Tool\n * \n * A dedicated MCP tool that returns the welcome message\n * This gives us more control over how the message is presented\n */\n\nimport { ConfigManager } from '../config/ConfigManager.js';\n\nexport interface GetWelcomeMessageOptions {\n  format?: 'text' | 'markdown' | 'raw';\n  skipCheck?: boolean;\n}\n\nexport class GetWelcomeMessageTool {\n  private configManager: ConfigManager;\n  \n  constructor() {\n    this.configManager = ConfigManager.getInstance();\n  }\n  \n  /**\n   * Get the welcome message directly as a tool response\n   * This bypasses the response wrapping and gives us full control\n   */\n  async execute(options: GetWelcomeMessageOptions = {}): Promise<any> {\n    await this.configManager.initialize();\n    const config = this.configManager.getConfig();\n    \n    // Check if we should show the welcome message\n    if (!options.skipCheck) {\n      if (config.wizard?.completed || config.wizard?.dismissed) {\n        return {\n          content: [{\n            type: \"text\",\n            text: \"Welcome back to DollhouseMCP! The wizard has already been completed. Use 'Open configuration wizard' if you want to reconfigure.\"\n          }]\n        };\n      }\n    }\n    \n    const welcomeMessage = `🎨 **Welcome to DollhouseMCP!**\n\nHi there! I see this is your first time here. DollhouseMCP helps you create powerful customization elements for your AI assistant - and it's easier than you might think!\n\n**What can you do with DollhouseMCP?**\n\n🎭 **Personas** - Change your AI's personality (make it funny, professional, creative, or anything you imagine)\n💡 **Skills** - Give your AI new abilities like taking meeting notes, reviewing code, or organizing your thoughts\n📝 **Templates** - Create reusable formats for emails, documentation, resumes, and more\n🤖 **Agents** - Build smart assistants that handle specific tasks automatically\n✨ **And more!** - Just describe what you want, and DollhouseMCP will help you create it\n\nThe best part? Everything you create is saved and persistent. Your custom tools and assistants will be there whenever you need them. You can modify them anytime just by asking!\n\n**Need ideas?** Just ask \"What would be the best way to...\" and I'll help you figure out the perfect solution.\n\n**Ready to get started?** I'll help you:\n- Choose a username (this tags your creations so you can find them later - or stay anonymous, that's totally fine!)\n- Set up your workspace for saving all your customizations\n- Browse examples to spark your creativity\n- Create your first customization element\n\nJust say:\n- \"Yes\" or \"Let's get started\" → I'll guide you through setup\n- \"Skip for now\" → You can set up later when you're ready\n- \"I'll stay anonymous\" → Perfect! You can use everything without signing in\n\n**What's a username for?** It simply tags your creations (like \"created by: you\") so you can find them easily. Staying anonymous means your creations are tagged with a fun random ID instead (like \"created by: clever-fox\"). Either way, all your work is saved locally on your computer!\n\nDon't worry - this only takes a minute, and you can change any settings later! 🌟`;\n    \n    // Return the message in the requested format\n    if (options.format === 'raw') {\n      // Just the text, no formatting\n      return welcomeMessage;\n    } else if (options.format === 'markdown') {\n      // Return as markdown code block\n      return {\n        content: [{\n          type: \"text\",\n          text: \"```markdown\\n\" + welcomeMessage + \"\\n```\"\n        }]\n      };\n    } else {\n      // Default: Return as clean text with instruction\n      return {\n        content: [{\n          type: \"text\",\n          text: welcomeMessage\n        }]\n      };\n    }\n  }\n  \n  /**\n   * Tool definition for MCP\n   */\n  static get definition() {\n    return {\n      name: \"dollhouse_welcome\",\n      description: \"Get the DollhouseMCP welcome message for first-time users\",\n      inputSchema: {\n        type: \"object\",\n        properties: {\n          format: {\n            type: \"string\",\n            enum: [\"text\", \"markdown\", \"raw\"],\n            description: \"Format for the welcome message (default: text)\"\n          },\n          skipCheck: {\n            type: \"boolean\",\n            description: \"Skip checking if wizard was already completed (default: false)\"\n          }\n        }\n      }\n    };\n  }\n}"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dollhousemcp/mcp-server",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "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.",
   "type": "module",
   "main": "dist/index.js",