@dollhousemcp/mcp-server 1.3.0

package/dist/server/ServerSetup.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Server setup and initialization
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { ToolRegistry } from './tools/ToolRegistry.js';
+import { IToolHandler } from './types.js';
+export declare class ServerSetup {
+    private toolRegistry;
+    constructor();
+    /**
+     * Initialize the server with all tools and handlers
+     */
+    setupServer(server: Server, instance: IToolHandler): void;
+    /**
+     * Register all tool categories
+     */
+    private registerTools;
+    /**
+     * Setup the ListToolsRequest handler
+     */
+    private setupListToolsHandler;
+    /**
+     * Setup the CallToolRequest handler
+     */
+    private setupCallToolHandler;
+    /**
+     * Recursively normalize Unicode in all string values within arguments
+     */
+    private normalizeArgumentsUnicode;
+    /**
+     * Get the tool registry
+     */
+    getToolRegistry(): ToolRegistry;
+}
+//# sourceMappingURL=ServerSetup.d.ts.map

package/dist/server/ServerSetup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerSetup.d.ts","sourceRoot":"","sources":["../../src/server/ServerSetup.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAEnE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAMvD,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI1C,qBAAa,WAAW;IACtB,OAAO,CAAC,YAAY,CAAe;;IAMnC;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAG,IAAI;IASzD;;OAEG;IACH,OAAO,CAAC,aAAa;IAiBrB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAQ7B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IA+B5B;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAmCjC;;OAEG;IACH,eAAe,IAAI,YAAY;CAGhC"}

package/dist/server/ServerSetup.js

@@ -0,0 +1,116 @@
+/**
+ * Server setup and initialization
+ */
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js";
+import { ToolRegistry } from './tools/ToolRegistry.js';
+import { getPersonaTools } from './tools/PersonaTools.js';
+import { getCollectionTools } from './tools/CollectionTools.js';
+import { getUserTools } from './tools/UserTools.js';
+import { getUpdateTools } from './tools/UpdateTools.js';
+import { getConfigTools } from './tools/ConfigTools.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+import { logger } from '../utils/logger.js';
+export class ServerSetup {
+    toolRegistry;
+    constructor() {
+        this.toolRegistry = new ToolRegistry();
+    }
+    /**
+     * Initialize the server with all tools and handlers
+     */
+    setupServer(server, instance) {
+        // Register all tools
+        this.registerTools(instance);
+        // Setup request handlers
+        this.setupListToolsHandler(server);
+        this.setupCallToolHandler(server);
+    }
+    /**
+     * Register all tool categories
+     */
+    registerTools(instance) {
+        // Register persona tools
+        this.toolRegistry.registerMany(getPersonaTools(instance));
+        // Register collection tools
+        this.toolRegistry.registerMany(getCollectionTools(instance));
+        // Register user tools
+        this.toolRegistry.registerMany(getUserTools(instance));
+        // Register update tools
+        this.toolRegistry.registerMany(getUpdateTools(instance));
+        // Register config tools
+        this.toolRegistry.registerMany(getConfigTools(instance));
+    }
+    /**
+     * Setup the ListToolsRequest handler
+     */
+    setupListToolsHandler(server) {
+        server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: this.toolRegistry.getAllTools()
+            };
+        });
+    }
+    /**
+     * Setup the CallToolRequest handler
+     */
+    setupCallToolHandler(server) {
+        server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                const handler = this.toolRegistry.getHandler(name);
+                if (!handler) {
+                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+                }
+                // Normalize Unicode in all string arguments to prevent security bypasses
+                const normalizedArgs = this.normalizeArgumentsUnicode(args, name);
+                return await handler(normalizedArgs);
+            }
+            catch (error) {
+                if (error instanceof McpError) {
+                    throw error;
+                }
+                throw new McpError(ErrorCode.InternalError, `Error executing tool ${name}: ${error}`);
+            }
+        });
+    }
+    /**
+     * Recursively normalize Unicode in all string values within arguments
+     */
+    normalizeArgumentsUnicode(args, toolName) {
+        if (args === null || args === undefined) {
+            return args;
+        }
+        if (typeof args === 'string') {
+            const result = UnicodeValidator.normalize(args);
+            if (result.detectedIssues && result.detectedIssues.length > 0) {
+                logger.warn(`Unicode security issues detected in tool ${toolName}:`, {
+                    issues: result.detectedIssues,
+                    severity: result.severity
+                });
+            }
+            return result.normalizedContent;
+        }
+        if (Array.isArray(args)) {
+            return args.map(item => this.normalizeArgumentsUnicode(item, toolName));
+        }
+        if (typeof args === 'object') {
+            const normalized = {};
+            for (const [key, value] of Object.entries(args)) {
+                // Normalize both keys and values to prevent Unicode attacks in property names
+                const normalizedKey = typeof key === 'string' ?
+                    UnicodeValidator.normalize(key).normalizedContent : key;
+                normalized[normalizedKey] = this.normalizeArgumentsUnicode(value, toolName);
+            }
+            return normalized;
+        }
+        // For non-string primitive types, return as-is
+        return args;
+    }
+    /**
+     * Get the tool registry
+     */
+    getToolRegistry() {
+        return this.toolRegistry;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ServerSetup.js","sourceRoot":"","sources":["../../src/server/ServerSetup.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Server setup and initialization\n */\n\nimport { Server } from \"@modelcontextprotocol/sdk/server/index.js\";\nimport { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from \"@modelcontextprotocol/sdk/types.js\";\nimport { ToolRegistry } from './tools/ToolRegistry.js';\nimport { getPersonaTools } from './tools/PersonaTools.js';\nimport { getCollectionTools } from './tools/CollectionTools.js';\nimport { getUserTools } from './tools/UserTools.js';\nimport { getUpdateTools } from './tools/UpdateTools.js';\nimport { getConfigTools } from './tools/ConfigTools.js';\nimport { IToolHandler } from './types.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { logger } from '../utils/logger.js';\n\nexport class ServerSetup {\n  private toolRegistry: ToolRegistry;\n  \n  constructor() {\n    this.toolRegistry = new ToolRegistry();\n  }\n  \n  /**\n   * Initialize the server with all tools and handlers\n   */\n  setupServer(server: Server, instance: IToolHandler): void {\n    // Register all tools\n    this.registerTools(instance);\n    \n    // Setup request handlers\n    this.setupListToolsHandler(server);\n    this.setupCallToolHandler(server);\n  }\n  \n  /**\n   * Register all tool categories\n   */\n  private registerTools(instance: IToolHandler): void {\n    // Register persona tools\n    this.toolRegistry.registerMany(getPersonaTools(instance));\n    \n    // Register collection tools\n    this.toolRegistry.registerMany(getCollectionTools(instance));\n    \n    // Register user tools\n    this.toolRegistry.registerMany(getUserTools(instance));\n    \n    // Register update tools\n    this.toolRegistry.registerMany(getUpdateTools(instance));\n    \n    // Register config tools\n    this.toolRegistry.registerMany(getConfigTools(instance));\n  }\n  \n  /**\n   * Setup the ListToolsRequest handler\n   */\n  private setupListToolsHandler(server: Server): void {\n    server.setRequestHandler(ListToolsRequestSchema, async () => {\n      return {\n        tools: this.toolRegistry.getAllTools()\n      };\n    });\n  }\n  \n  /**\n   * Setup the CallToolRequest handler\n   */\n  private setupCallToolHandler(server: Server): void {\n    server.setRequestHandler(CallToolRequestSchema, async (request) => {\n      const { name, arguments: args } = request.params;\n      \n      try {\n        const handler = this.toolRegistry.getHandler(name);\n        \n        if (!handler) {\n          throw new McpError(\n            ErrorCode.MethodNotFound,\n            `Unknown tool: ${name}`\n          );\n        }\n        \n        // Normalize Unicode in all string arguments to prevent security bypasses\n        const normalizedArgs = this.normalizeArgumentsUnicode(args, name);\n        \n        return await handler(normalizedArgs);\n      } catch (error) {\n        if (error instanceof McpError) {\n          throw error;\n        }\n        \n        throw new McpError(\n          ErrorCode.InternalError,\n          `Error executing tool ${name}: ${error}`\n        );\n      }\n    });\n  }\n  \n  /**\n   * Recursively normalize Unicode in all string values within arguments\n   */\n  private normalizeArgumentsUnicode(args: any, toolName: string): any {\n    if (args === null || args === undefined) {\n      return args;\n    }\n    \n    if (typeof args === 'string') {\n      const result = UnicodeValidator.normalize(args);\n      if (result.detectedIssues && result.detectedIssues.length > 0) {\n        logger.warn(`Unicode security issues detected in tool ${toolName}:`, {\n          issues: result.detectedIssues,\n          severity: result.severity\n        });\n      }\n      return result.normalizedContent;\n    }\n    \n    if (Array.isArray(args)) {\n      return args.map(item => this.normalizeArgumentsUnicode(item, toolName));\n    }\n    \n    if (typeof args === 'object') {\n      const normalized: any = {};\n      for (const [key, value] of Object.entries(args)) {\n        // Normalize both keys and values to prevent Unicode attacks in property names\n        const normalizedKey = typeof key === 'string' ? \n          UnicodeValidator.normalize(key).normalizedContent : key;\n        normalized[normalizedKey] = this.normalizeArgumentsUnicode(value, toolName);\n      }\n      return normalized;\n    }\n    \n    // For non-string primitive types, return as-is\n    return args;\n  }\n  \n  /**\n   * Get the tool registry\n   */\n  getToolRegistry(): ToolRegistry {\n    return this.toolRegistry;\n  }\n}"]}

package/dist/server/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Server module exports
+ */
+export * from './ServerSetup.js';
+export * from './tools/index.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}

package/dist/server/index.js

@@ -0,0 +1,7 @@
+/**
+ * Server module exports
+ */
+export * from './ServerSetup.js';
+export * from './tools/index.js';
+export * from './types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VydmVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsWUFBWSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBTZXJ2ZXIgbW9kdWxlIGV4cG9ydHNcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL1NlcnZlclNldHVwLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vdG9vbHMvaW5kZXguanMnO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcy5qcyc7Il19

package/dist/server/startup.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Server startup utilities including migration
+ */
+import { ElementType } from '../portfolio/PortfolioManager.js';
+export interface StartupOptions {
+    skipMigration?: boolean;
+    autoBackup?: boolean;
+}
+export declare class ServerStartup {
+    private portfolioManager;
+    private migrationManager;
+    constructor();
+    /**
+     * Initialize server with migration check
+     */
+    initialize(options?: StartupOptions): Promise<void>;
+    /**
+     * Get migration status without performing migration
+     */
+    getMigrationStatus(): Promise<{
+        hasLegacyPersonas: boolean;
+        legacyPersonaCount: number;
+        portfolioExists: boolean;
+        portfolioStats: Record<ElementType, number>;
+    }>;
+    /**
+     * Get the personas directory path for legacy compatibility
+     */
+    getPersonasDir(): string;
+}
+//# sourceMappingURL=startup.d.ts.map

package/dist/server/startup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startup.d.ts","sourceRoot":"","sources":["../../src/server/startup.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAIjF,MAAM,WAAW,cAAc;IAC7B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,gBAAgB,CAAmB;;IAO3C;;OAEG;IACG,UAAU,CAAC,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IA2C7D;;OAEG;IACG,kBAAkB;;;;;;IAIxB;;OAEG;IACH,cAAc,IAAI,MAAM;CAGzB"}

package/dist/server/startup.js

@@ -0,0 +1,67 @@
+/**
+ * Server startup utilities including migration
+ */
+import { PortfolioManager, ElementType } from '../portfolio/PortfolioManager.js';
+import { MigrationManager } from '../portfolio/MigrationManager.js';
+import { logger } from '../utils/logger.js';
+export class ServerStartup {
+    portfolioManager;
+    migrationManager;
+    constructor() {
+        this.portfolioManager = PortfolioManager.getInstance();
+        this.migrationManager = new MigrationManager(this.portfolioManager);
+    }
+    /**
+     * Initialize server with migration check
+     */
+    async initialize(options = {}) {
+        logger.info('[ServerStartup] Initializing server...');
+        // Check if migration is needed
+        if (!options.skipMigration) {
+            const needsMigration = await this.migrationManager.needsMigration();
+            if (needsMigration) {
+                logger.info('[ServerStartup] Legacy personas detected. Starting migration...');
+                const result = await this.migrationManager.migrate({
+                    backup: options.autoBackup !== false // Default to true
+                });
+                if (result.success) {
+                    logger.info(`[ServerStartup] Successfully migrated ${result.migratedCount} personas`);
+                    if (result.backedUp && result.backupPath) {
+                        logger.info(`[ServerStartup] Backup created at: ${result.backupPath}`);
+                    }
+                }
+                else {
+                    logger.error('[ServerStartup] Migration completed with errors:');
+                    result.errors.forEach(err => logger.error(`[ServerStartup]   - ${err}`));
+                }
+            }
+        }
+        // Ensure portfolio structure exists
+        const portfolioExists = await this.portfolioManager.exists();
+        if (!portfolioExists) {
+            logger.info('[ServerStartup] Creating portfolio directory structure...');
+            await this.portfolioManager.initialize();
+        }
+        // Log portfolio statistics
+        const stats = await this.portfolioManager.getStatistics();
+        logger.info('[ServerStartup] Portfolio statistics:');
+        Object.entries(stats).forEach(([type, count]) => {
+            if (count > 0) {
+                logger.info(`[ServerStartup]   - ${type}: ${count} elements`);
+            }
+        });
+    }
+    /**
+     * Get migration status without performing migration
+     */
+    async getMigrationStatus() {
+        return await this.migrationManager.getMigrationStatus();
+    }
+    /**
+     * Get the personas directory path for legacy compatibility
+     */
+    getPersonasDir() {
+        return this.portfolioManager.getElementDir(ElementType.PERSONA);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/server/tools/CollectionTools.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Collection-related tool definitions and handlers
+ */
+import { ToolDefinition } from './ToolRegistry.js';
+import { IToolHandler } from '../types.js';
+export declare function getCollectionTools(server: IToolHandler): Array<{
+    tool: ToolDefinition;
+    handler: any;
+}>;
+//# sourceMappingURL=CollectionTools.d.ts.map

package/dist/server/tools/CollectionTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CollectionTools.d.ts","sourceRoot":"","sources":["../../../src/server/tools/CollectionTools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,CA2FtG"}

package/dist/server/tools/CollectionTools.js

@@ -0,0 +1,96 @@
+/**
+ * Collection-related tool definitions and handlers
+ */
+export function getCollectionTools(server) {
+    return [
+        {
+            tool: {
+                name: "browse_collection",
+                description: "Browse content from the DollhouseMCP collection by section and content type. Content types include personas (AI behavioral profiles), skills, agents, prompts, templates, tools, and ensembles. When users ask for 'personas', they're referring to content in the personas type.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        section: {
+                            type: "string",
+                            description: "Collection section to browse (library, showcase, catalog). Leave empty to see all sections.",
+                        },
+                        type: {
+                            type: "string",
+                            description: "Content type within the library section: personas, skills, agents, prompts, templates, tools, or ensembles. Only used when section is 'library'.",
+                        },
+                    },
+                },
+            },
+            handler: (args) => server.browseCollection(args?.section, args?.type)
+        },
+        {
+            tool: {
+                name: "search_collection",
+                description: "Search for content in the collection by keywords. This searches all content types including personas (AI behavioral profiles that users activate to change AI behavior), skills, agents, prompts, etc. When a user asks to 'find a persona', search in the collection.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: {
+                            type: "string",
+                            description: "Search query for finding content. Examples: 'creative writer', 'explain like I'm five', 'coding assistant'. Users typically search for personas by their behavioral traits or names.",
+                        },
+                    },
+                    required: ["query"],
+                },
+            },
+            handler: (args) => server.searchCollection(args.query)
+        },
+        {
+            tool: {
+                name: "get_collection_content",
+                description: "Get detailed information about content from the collection. Use this when users ask to 'see details about a persona' or 'show me the creative writer persona'. Personas are a type of content that defines AI behavioral profiles.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "The collection path to the AI customization element. Format: 'library/[type]/[element].md' where type is personas, skills, templates, agents, memories, or ensembles. Example: 'library/skills/code-review.md'.",
+                        },
+                    },
+                    required: ["path"],
+                },
+            },
+            handler: (args) => server.getCollectionContent(args.path)
+        },
+        {
+            tool: {
+                name: "install_content",
+                description: "Install AI customization elements from the collection to your local portfolio. Use this when users ask to download/install any element type (personas, skills, templates, agents, memories, or ensembles). Examples: 'install the creative writer persona', 'get the code review skill', 'download the meeting notes template'.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "The collection path to the AI customization element. Format: 'library/[type]/[element].md' where type is personas, skills, templates, agents, memories, or ensembles. Example: 'library/skills/code-review.md'.",
+                        },
+                    },
+                    required: ["path"],
+                },
+            },
+            handler: (args) => server.installContent(args.path)
+        },
+        {
+            tool: {
+                name: "submit_content",
+                description: "Submit local content to the collection for community review. Use this when users want to 'share their persona' or 'submit a persona to the collection'. This handles all content types including personas (AI behavioral profiles).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        content: {
+                            type: "string",
+                            description: "The content name or filename to submit. For personas, use the persona's name (e.g., 'Creative Writer') or filename. The system will recognize it as a persona based on its metadata.",
+                        },
+                    },
+                    required: ["content"],
+                },
+            },
+            handler: (args) => server.submitContent(args.content)
+        }
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CollectionTools.js","sourceRoot":"","sources":["../../../src/server/tools/CollectionTools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,MAAM,UAAU,kBAAkB,CAAC,MAAoB;IACrD,OAAO;QACL;YACE,IAAI,EAAE;gBACJ,IAAI,EAAE,mBAAmB;gBACzB,WAAW,EAAE,mRAAmR;gBAChS,WAAW,EAAE;oBACX,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE;wBACV,OAAO,EAAE;4BACP,IAAI,EAAE,QAAQ;4BACd,WAAW,EAAE,6FAA6F;yBAC3G;wBACD,IAAI,EAAE;4BACJ,IAAI,EAAE,QAAQ;4BACd,WAAW,EAAE,kJAAkJ;yBAChK;qBACF;iBACF;aACF;YACD,OAAO,EAAE,CAAC,IAAS,EAAE,EAAE,CAAC,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC;SAC3E;QACD;YACE,IAAI,EAAE;gBACJ,IAAI,EAAE,mBAAmB;gBACzB,WAAW,EAAE,wQAAwQ;gBACrR,WAAW,EAAE;oBACX,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE;wBACV,KAAK,EAAE;4BACL,IAAI,EAAE,QAAQ;4BACd,WAAW,EAAE,sLAAsL;yBACpM;qBACF;oBACD,QAAQ,EAAE,CAAC,OAAO,CAAC;iBACpB;aACF;YACD,OAAO,EAAE,CAAC,IAAS,EAAE,EAAE,CAAC,MAAM,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC;SAC5D;QACD;YACE,IAAI,EAAE;gBACJ,IAAI,EAAE,wBAAwB;gBAC9B,WAAW,EAAE,oOAAoO;gBACjP,WAAW,EAAE;oBACX,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE;wBACV,IAAI,EAAE;4BACJ,IAAI,EAAE,QAAQ;4BACd,WAAW,EAAE,iNAAiN;yBAC/N;qBACF;oBACD,QAAQ,EAAE,CAAC,MAAM,CAAC;iBACnB;aACF;YACD,OAAO,EAAE,CAAC,IAAS,EAAE,EAAE,CAAC,MAAM,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC;SAC/D;QACD;YACE,IAAI,EAAE;gBACJ,IAAI,EAAE,iBAAiB;gBACvB,WAAW,EAAE,iUAAiU;gBAC9U,WAAW,EAAE;oBACX,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE;wBACV,IAAI,EAAE;4BACJ,IAAI,EAAE,QAAQ;4BACd,WAAW,EAAE,iNAAiN;yBAC/N;qBACF;oBACD,QAAQ,EAAE,CAAC,MAAM,CAAC;iBACnB;aACF;YACD,OAAO,EAAE,CAAC,IAAS,EAAE,EAAE,CAAC,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC;SACzD;QACD;YACE,IAAI,EAAE;gBACJ,IAAI,EAAE,gBAAgB;gBACtB,WAAW,EAAE,qOAAqO;gBAClP,WAAW,EAAE;oBACX,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE;wBACV,OAAO,EAAE;4BACP,IAAI,EAAE,QAAQ;4BACd,WAAW,EAAE,sLAAsL;yBACpM;qBACF;oBACD,QAAQ,EAAE,CAAC,SAAS,CAAC;iBACtB;aACF;YACD,OAAO,EAAE,CAAC,IAAS,EAAE,EAAE,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC;SAC3D;KACF,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Collection-related tool definitions and handlers\n */\n\nimport { ToolDefinition } from './ToolRegistry.js';\nimport { IToolHandler } from '../types.js';\n\nexport function getCollectionTools(server: IToolHandler): Array<{ tool: ToolDefinition; handler: any }> {\n  return [\n    {\n      tool: {\n        name: \"browse_collection\",\n        description: \"Browse content from the DollhouseMCP collection by section and content type. Content types include personas (AI behavioral profiles), skills, agents, prompts, templates, tools, and ensembles. When users ask for 'personas', they're referring to content in the personas type.\",\n        inputSchema: {\n          type: \"object\",\n          properties: {\n            section: {\n              type: \"string\",\n              description: \"Collection section to browse (library, showcase, catalog). Leave empty to see all sections.\",\n            },\n            type: {\n              type: \"string\",\n              description: \"Content type within the library section: personas, skills, agents, prompts, templates, tools, or ensembles. Only used when section is 'library'.\",\n            },\n          },\n        },\n      },\n      handler: (args: any) => server.browseCollection(args?.section, args?.type)\n    },\n    {\n      tool: {\n        name: \"search_collection\",\n        description: \"Search for content in the collection by keywords. This searches all content types including personas (AI behavioral profiles that users activate to change AI behavior), skills, agents, prompts, etc. When a user asks to 'find a persona', search in the collection.\",\n        inputSchema: {\n          type: \"object\",\n          properties: {\n            query: {\n              type: \"string\",\n              description: \"Search query for finding content. Examples: 'creative writer', 'explain like I'm five', 'coding assistant'. Users typically search for personas by their behavioral traits or names.\",\n            },\n          },\n          required: [\"query\"],\n        },\n      },\n      handler: (args: any) => server.searchCollection(args.query)\n    },\n    {\n      tool: {\n        name: \"get_collection_content\",\n        description: \"Get detailed information about content from the collection. Use this when users ask to 'see details about a persona' or 'show me the creative writer persona'. Personas are a type of content that defines AI behavioral profiles.\",\n        inputSchema: {\n          type: \"object\",\n          properties: {\n            path: {\n              type: \"string\",\n              description: \"The collection path to the AI customization element. Format: 'library/[type]/[element].md' where type is personas, skills, templates, agents, memories, or ensembles. Example: 'library/skills/code-review.md'.\",\n            },\n          },\n          required: [\"path\"],\n        },\n      },\n      handler: (args: any) => server.getCollectionContent(args.path)\n    },\n    {\n      tool: {\n        name: \"install_content\",\n        description: \"Install AI customization elements from the collection to your local portfolio. Use this when users ask to download/install any element type (personas, skills, templates, agents, memories, or ensembles). Examples: 'install the creative writer persona', 'get the code review skill', 'download the meeting notes template'.\",\n        inputSchema: {\n          type: \"object\",\n          properties: {\n            path: {\n              type: \"string\",\n              description: \"The collection path to the AI customization element. Format: 'library/[type]/[element].md' where type is personas, skills, templates, agents, memories, or ensembles. Example: 'library/skills/code-review.md'.\",\n            },\n          },\n          required: [\"path\"],\n        },\n      },\n      handler: (args: any) => server.installContent(args.path)\n    },\n    {\n      tool: {\n        name: \"submit_content\",\n        description: \"Submit local content to the collection for community review. Use this when users want to 'share their persona' or 'submit a persona to the collection'. This handles all content types including personas (AI behavioral profiles).\",\n        inputSchema: {\n          type: \"object\",\n          properties: {\n            content: {\n              type: \"string\",\n              description: \"The content name or filename to submit. For personas, use the persona's name (e.g., 'Creative Writer') or filename. The system will recognize it as a persona based on its metadata.\",\n            },\n          },\n          required: [\"content\"],\n        },\n      },\n      handler: (args: any) => server.submitContent(args.content)\n    }\n  ];\n}"]}

package/dist/server/tools/ConfigTools.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Configuration-related tool definitions and handlers
+ */
+import { ToolDefinition } from './ToolRegistry.js';
+import { IToolHandler } from '../types.js';
+export declare function getConfigTools(server: IToolHandler): Array<{
+    tool: ToolDefinition;
+    handler: any;
+}>;
+//# sourceMappingURL=ConfigTools.d.ts.map

package/dist/server/tools/ConfigTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigTools.d.ts","sourceRoot":"","sources":["../../../src/server/tools/ConfigTools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,CA0DlG"}

package/dist/server/tools/ConfigTools.js

@@ -0,0 +1,63 @@
+/**
+ * Configuration-related tool definitions and handlers
+ */
+export function getConfigTools(server) {
+    return [
+        {
+            tool: {
+                name: "configure_indicator",
+                description: "Configure how active persona indicators are displayed",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        enabled: {
+                            type: "boolean",
+                            description: "Enable or disable persona indicators",
+                        },
+                        style: {
+                            type: "string",
+                            description: "Display style: full, minimal, compact, or custom",
+                        },
+                        customFormat: {
+                            type: "string",
+                            description: "Custom format string (for style=custom). Use placeholders: {name}, {version}, {author}, {category}",
+                        },
+                        includeEmoji: {
+                            type: "boolean",
+                            description: "Include emoji in indicator (🎭)",
+                        },
+                        includeBrackets: {
+                            type: "boolean",
+                            description: "Wrap indicator in brackets",
+                        },
+                        includeVersion: {
+                            type: "boolean",
+                            description: "Include version in indicator",
+                        },
+                        includeAuthor: {
+                            type: "boolean",
+                            description: "Include author in indicator",
+                        },
+                        includeCategory: {
+                            type: "boolean",
+                            description: "Include category in indicator",
+                        },
+                    },
+                },
+            },
+            handler: (args) => server.configureIndicator(args)
+        },
+        {
+            tool: {
+                name: "get_indicator_config",
+                description: "Get current persona indicator configuration",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            handler: () => server.getIndicatorConfig()
+        }
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/server/tools/MarketplaceTools.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Marketplace-related tool definitions and handlers
+ */
+import { ToolDefinition } from './ToolRegistry.js';
+import { IToolHandler } from '../types.js';
+export declare function getMarketplaceTools(server: IToolHandler): Array<{
+    tool: ToolDefinition;
+    handler: any;
+}>;
+//# sourceMappingURL=MarketplaceTools.d.ts.map

package/dist/server/tools/MarketplaceTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarketplaceTools.d.ts","sourceRoot":"","sources":["../../../src/server/tools/MarketplaceTools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,CA2FvG"}