@dollhousemcp/mcp-server 1.9.2 → 1.9.3

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.9.2",
+  "version": "1.9.3",
   "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",