@dollhousemcp/mcp-server 1.7.3 → 1.7.4

package/dist/sync/PortfolioDownloader.js

@@ -0,0 +1,120 @@
+/**
+ * PortfolioDownloader - Downloads elements from GitHub repositories
+ *
+ * Handles fetching file contents from GitHub, decoding base64 content,
+ * and returning structured element data ready for local storage.
+ */
+import { logger } from '../utils/logger.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+export class PortfolioDownloader {
+    /**
+     * Download an element from GitHub
+     */
+    async downloadFromGitHub(repoManager, elementPath, username, repository) {
+        try {
+            logger.info('Downloading element from GitHub', {
+                path: elementPath,
+                username,
+                repository
+            });
+            // Fetch the file content from GitHub
+            const response = await repoManager.githubRequest(`/repos/${username}/${repository}/contents/${elementPath}`);
+            if (!response || !response.content) {
+                throw new Error(`No content found at path: ${elementPath}`);
+            }
+            // Decode base64 content
+            const decodedContent = Buffer.from(response.content, 'base64').toString('utf-8');
+            // Normalize Unicode for security
+            const normalized = UnicodeValidator.normalize(decodedContent);
+            // Log download for audit trail
+            logger.info('Element downloaded successfully', {
+                path: elementPath,
+                repository: `${username}/${repository}`,
+                sha: response.sha
+            });
+            // Parse metadata from frontmatter if present
+            const metadata = this.extractMetadata(normalized.normalizedContent);
+            return {
+                content: normalized.normalizedContent,
+                metadata,
+                sha: response.sha
+            };
+        }
+        catch (error) {
+            logger.error('Failed to download element from GitHub', {
+                error,
+                path: elementPath
+            });
+            // Re-throw with more context
+            if (error instanceof Error) {
+                if (error.message.includes('404')) {
+                    throw new Error(`Element not found at path: ${elementPath}`);
+                }
+                if (error.message.includes('401') || error.message.includes('403')) {
+                    throw new Error(`Authentication failed. Please check your GitHub token.`);
+                }
+                throw error;
+            }
+            throw new Error(`Failed to download ${elementPath}: ${String(error)}`);
+        }
+    }
+    /**
+     * Extract metadata from frontmatter
+     */
+    extractMetadata(content) {
+        const metadata = {};
+        // Check for YAML frontmatter
+        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        if (frontmatterMatch) {
+            try {
+                // Parse the frontmatter as simple key-value pairs
+                // (avoiding using yaml.load for security)
+                const frontmatterContent = frontmatterMatch[1];
+                const lines = frontmatterContent.split('\n');
+                for (const line of lines) {
+                    const colonIndex = line.indexOf(':');
+                    if (colonIndex > 0) {
+                        const key = line.substring(0, colonIndex).trim();
+                        const value = line.substring(colonIndex + 1).trim();
+                        // Remove quotes if present
+                        const cleanValue = value.replace(/^["']|["']$/g, '');
+                        // Try to parse as JSON for arrays/objects, otherwise use as string
+                        try {
+                            metadata[key] = JSON.parse(cleanValue);
+                        }
+                        catch {
+                            metadata[key] = cleanValue;
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                logger.warn('Failed to parse frontmatter metadata', { error });
+            }
+        }
+        return metadata;
+    }
+    /**
+     * Download multiple elements in batch
+     */
+    async downloadBatch(repoManager, elementPaths, username, repository, onProgress) {
+        const results = new Map();
+        let downloaded = 0;
+        for (const path of elementPaths) {
+            try {
+                const elementData = await this.downloadFromGitHub(repoManager, path, username, repository);
+                results.set(path, elementData);
+                downloaded++;
+                if (onProgress) {
+                    onProgress(downloaded, elementPaths.length);
+                }
+            }
+            catch (error) {
+                logger.error(`Failed to download ${path}`, { error });
+                // Continue with other downloads even if one fails
+            }
+        }
+        return results;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PortfolioDownloader.js","sourceRoot":"","sources":["../../src/sync/PortfolioDownloader.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * PortfolioDownloader - Downloads elements from GitHub repositories\n * \n * Handles fetching file contents from GitHub, decoding base64 content,\n * and returning structured element data ready for local storage.\n */\n\nimport { PortfolioRepoManager } from '../portfolio/PortfolioRepoManager.js';\nimport { logger } from '../utils/logger.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\n\nexport interface ElementData {\n  content: string;\n  metadata: Record<string, any>;\n  sha: string;\n}\n\nexport class PortfolioDownloader {\n  /**\n   * Download an element from GitHub\n   */\n  async downloadFromGitHub(\n    repoManager: PortfolioRepoManager,\n    elementPath: string,\n    username: string,\n    repository: string\n  ): Promise<ElementData> {\n    try {\n      logger.info('Downloading element from GitHub', { \n        path: elementPath, \n        username, \n        repository \n      });\n\n      // Fetch the file content from GitHub\n      const response = await repoManager.githubRequest(\n        `/repos/${username}/${repository}/contents/${elementPath}`\n      );\n\n      if (!response || !response.content) {\n        throw new Error(`No content found at path: ${elementPath}`);\n      }\n\n      // Decode base64 content\n      const decodedContent = Buffer.from(response.content, 'base64').toString('utf-8');\n      \n      // Normalize Unicode for security\n      const normalized = UnicodeValidator.normalize(decodedContent);\n      \n      // Log download for audit trail\n      logger.info('Element downloaded successfully', {\n        path: elementPath,\n        repository: `${username}/${repository}`,\n        sha: response.sha\n      });\n\n      // Parse metadata from frontmatter if present\n      const metadata = this.extractMetadata(normalized.normalizedContent);\n\n      return {\n        content: normalized.normalizedContent,\n        metadata,\n        sha: response.sha\n      };\n      \n    } catch (error) {\n      logger.error('Failed to download element from GitHub', { \n        error, \n        path: elementPath \n      });\n      \n      // Re-throw with more context\n      if (error instanceof Error) {\n        if (error.message.includes('404')) {\n          throw new Error(`Element not found at path: ${elementPath}`);\n        }\n        if (error.message.includes('401') || error.message.includes('403')) {\n          throw new Error(`Authentication failed. Please check your GitHub token.`);\n        }\n        throw error;\n      }\n      \n      throw new Error(`Failed to download ${elementPath}: ${String(error)}`);\n    }\n  }\n\n  /**\n   * Extract metadata from frontmatter\n   */\n  private extractMetadata(content: string): Record<string, any> {\n    const metadata: Record<string, any> = {};\n    \n    // Check for YAML frontmatter\n    const frontmatterMatch = content.match(/^---\\n([\\s\\S]*?)\\n---/);\n    \n    if (frontmatterMatch) {\n      try {\n        // Parse the frontmatter as simple key-value pairs\n        // (avoiding using yaml.load for security)\n        const frontmatterContent = frontmatterMatch[1];\n        const lines = frontmatterContent.split('\\n');\n        \n        for (const line of lines) {\n          const colonIndex = line.indexOf(':');\n          if (colonIndex > 0) {\n            const key = line.substring(0, colonIndex).trim();\n            const value = line.substring(colonIndex + 1).trim();\n            \n            // Remove quotes if present\n            const cleanValue = value.replace(/^[\"']|[\"']$/g, '');\n            \n            // Try to parse as JSON for arrays/objects, otherwise use as string\n            try {\n              metadata[key] = JSON.parse(cleanValue);\n            } catch {\n              metadata[key] = cleanValue;\n            }\n          }\n        }\n      } catch (error) {\n        logger.warn('Failed to parse frontmatter metadata', { error });\n      }\n    }\n    \n    return metadata;\n  }\n\n  /**\n   * Download multiple elements in batch\n   */\n  async downloadBatch(\n    repoManager: PortfolioRepoManager,\n    elementPaths: string[],\n    username: string,\n    repository: string,\n    onProgress?: (downloaded: number, total: number) => void\n  ): Promise<Map<string, ElementData>> {\n    const results = new Map<string, ElementData>();\n    let downloaded = 0;\n    \n    for (const path of elementPaths) {\n      try {\n        const elementData = await this.downloadFromGitHub(\n          repoManager,\n          path,\n          username,\n          repository\n        );\n        \n        results.set(path, elementData);\n        downloaded++;\n        \n        if (onProgress) {\n          onProgress(downloaded, elementPaths.length);\n        }\n      } catch (error) {\n        logger.error(`Failed to download ${path}`, { error });\n        // Continue with other downloads even if one fails\n      }\n    }\n    \n    return results;\n  }\n}"]}

package/dist/sync/PortfolioSyncComparer.d.ts

@@ -0,0 +1,50 @@
+/**
+ * PortfolioSyncComparer - Compares local and GitHub portfolio elements
+ *
+ * Determines what actions need to be taken based on the sync mode:
+ * - additive: Only add missing elements
+ * - mirror: Make local exactly match GitHub
+ * - backup: Treat GitHub as authoritative source
+ */
+import { ElementType } from '../portfolio/types.js';
+import { GitHubIndexEntry } from '../portfolio/GitHubPortfolioIndexer.js';
+export type SyncMode = 'additive' | 'mirror' | 'backup';
+export interface SyncAction {
+    type: ElementType;
+    name: string;
+    path: string;
+    action: 'add' | 'update' | 'delete' | 'skip';
+    reason?: string;
+    localSha?: string;
+    remoteSha?: string;
+}
+export interface SyncActions {
+    toAdd: SyncAction[];
+    toUpdate: SyncAction[];
+    toDelete: SyncAction[];
+    toSkip: SyncAction[];
+}
+export declare class PortfolioSyncComparer {
+    /**
+     * Compare GitHub and local elements to determine sync actions
+     */
+    compareElements(githubElements: Map<ElementType, GitHubIndexEntry[]>, localElements: Map<ElementType, any[]>, mode: SyncMode): SyncActions;
+    /**
+     * Compare elements of a specific type
+     */
+    private compareTypeElements;
+    /**
+     * Determine if an element should be updated
+     */
+    private shouldUpdate;
+    /**
+     * Normalize element name for comparison
+     * Handles different naming formats and extensions
+     */
+    private normalizeElementName;
+    /**
+     * Count total elements in a map
+     */
+    private countElements;
+}
+//# sourceMappingURL=PortfolioSyncComparer.d.ts.map

package/dist/sync/PortfolioSyncComparer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PortfolioSyncComparer.d.ts","sourceRoot":"","sources":["../../src/sync/PortfolioSyncComparer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wCAAwC,CAAC;AAG1E,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAExD,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,KAAK,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,MAAM,EAAE,UAAU,EAAE,CAAC;CACtB;AAED,qBAAa,qBAAqB;IAChC;;OAEG;IACH,eAAe,CACb,cAAc,EAAE,GAAG,CAAC,WAAW,EAAE,gBAAgB,EAAE,CAAC,EACpD,aAAa,EAAE,GAAG,CAAC,WAAW,EAAE,GAAG,EAAE,CAAC,EACtC,IAAI,EAAE,QAAQ,GACb,WAAW;IA2Cd;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAuE3B;;OAEG;IACH,OAAO,CAAC,YAAY;IAgCpB;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAe5B;;OAEG;IACH,OAAO,CAAC,aAAa;CAOtB"}

package/dist/sync/PortfolioSyncComparer.js

@@ -0,0 +1,158 @@
+/**
+ * PortfolioSyncComparer - Compares local and GitHub portfolio elements
+ *
+ * Determines what actions need to be taken based on the sync mode:
+ * - additive: Only add missing elements
+ * - mirror: Make local exactly match GitHub
+ * - backup: Treat GitHub as authoritative source
+ */
+import { logger } from '../utils/logger.js';
+export class PortfolioSyncComparer {
+    /**
+     * Compare GitHub and local elements to determine sync actions
+     */
+    compareElements(githubElements, localElements, mode) {
+        const actions = {
+            toAdd: [],
+            toUpdate: [],
+            toDelete: [],
+            toSkip: []
+        };
+        logger.info('Comparing elements', {
+            githubCount: this.countElements(githubElements),
+            localCount: this.countElements(localElements),
+            mode
+        });
+        // Process each element type
+        const allTypes = new Set([
+            ...githubElements.keys(),
+            ...localElements.keys()
+        ]);
+        for (const type of allTypes) {
+            const githubTypeElements = githubElements.get(type) || [];
+            const localTypeElements = localElements.get(type) || [];
+            this.compareTypeElements(type, githubTypeElements, localTypeElements, mode, actions);
+        }
+        logger.info('Comparison complete', {
+            toAdd: actions.toAdd.length,
+            toUpdate: actions.toUpdate.length,
+            toDelete: actions.toDelete.length,
+            toSkip: actions.toSkip.length
+        });
+        return actions;
+    }
+    /**
+     * Compare elements of a specific type
+     */
+    compareTypeElements(type, githubElements, localElements, mode, actions) {
+        // Create maps for efficient lookup
+        const githubMap = new Map(githubElements.map(e => [this.normalizeElementName(e.name), e]));
+        const localMap = new Map(localElements.map(e => [this.normalizeElementName(e.name || e.metadata?.name), e]));
+        // Process GitHub elements (additions and updates)
+        for (const [name, githubElement] of githubMap) {
+            const localElement = localMap.get(name);
+            if (!localElement) {
+                // Element exists on GitHub but not locally
+                actions.toAdd.push({
+                    type,
+                    name: githubElement.name,
+                    path: githubElement.path,
+                    action: 'add',
+                    remoteSha: githubElement.sha
+                });
+            }
+            else if (mode === 'backup' || this.shouldUpdate(githubElement, localElement, mode)) {
+                // Element needs updating
+                actions.toUpdate.push({
+                    type,
+                    name: githubElement.name,
+                    path: githubElement.path,
+                    action: 'update',
+                    reason: mode === 'backup' ? 'backup mode' : 'newer on GitHub',
+                    localSha: localElement.sha,
+                    remoteSha: githubElement.sha
+                });
+            }
+            else {
+                // Element is up to date or should be skipped
+                actions.toSkip.push({
+                    type,
+                    name: githubElement.name,
+                    path: githubElement.path,
+                    action: 'skip',
+                    reason: 'up to date',
+                    localSha: localElement.sha,
+                    remoteSha: githubElement.sha
+                });
+            }
+        }
+        // Process local elements (deletions - only in mirror mode)
+        if (mode === 'mirror') {
+            for (const [name, localElement] of localMap) {
+                if (!githubMap.has(name)) {
+                    // Element exists locally but not on GitHub
+                    actions.toDelete.push({
+                        type,
+                        name: localElement.name || localElement.metadata?.name || name,
+                        path: `${type}/${name}.md`,
+                        action: 'delete',
+                        reason: 'not on GitHub',
+                        localSha: localElement.sha
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Determine if an element should be updated
+     */
+    shouldUpdate(githubElement, localElement, mode) {
+        // In backup mode, always update from GitHub
+        if (mode === 'backup') {
+            return true;
+        }
+        // In additive mode, never update existing elements
+        if (mode === 'additive') {
+            return false;
+        }
+        // In mirror mode, update if SHAs differ
+        // If we don't have SHAs, compare modified dates
+        if (githubElement.sha && localElement.sha) {
+            return githubElement.sha !== localElement.sha;
+        }
+        // Compare modified dates if available
+        if (githubElement.lastModified && localElement.lastModified) {
+            const githubDate = new Date(githubElement.lastModified).getTime();
+            const localDate = new Date(localElement.lastModified).getTime();
+            return githubDate > localDate;
+        }
+        // If we can't determine, skip updating in mirror mode
+        return false;
+    }
+    /**
+     * Normalize element name for comparison
+     * Handles different naming formats and extensions
+     */
+    normalizeElementName(name) {
+        if (!name)
+            return '';
+        // Remove .md extension if present
+        let normalized = name.replace(/\.md$/i, '');
+        // Convert to lowercase for comparison
+        normalized = normalized.toLowerCase();
+        // Replace spaces with hyphens (some systems use different formats)
+        normalized = normalized.replace(/\s+/g, '-');
+        return normalized;
+    }
+    /**
+     * Count total elements in a map
+     */
+    countElements(elements) {
+        let count = 0;
+        for (const typeElements of elements.values()) {
+            count += typeElements.length;
+        }
+        return count;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PortfolioSyncComparer.js","sourceRoot":"","sources":["../../src/sync/PortfolioSyncComparer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * PortfolioSyncComparer - Compares local and GitHub portfolio elements\n * \n * Determines what actions need to be taken based on the sync mode:\n * - additive: Only add missing elements\n * - mirror: Make local exactly match GitHub\n * - backup: Treat GitHub as authoritative source\n */\n\nimport { ElementType } from '../portfolio/types.js';\nimport { GitHubIndexEntry } from '../portfolio/GitHubPortfolioIndexer.js';\nimport { logger } from '../utils/logger.js';\n\nexport type SyncMode = 'additive' | 'mirror' | 'backup';\n\nexport interface SyncAction {\n  type: ElementType;\n  name: string;\n  path: string;\n  action: 'add' | 'update' | 'delete' | 'skip';\n  reason?: string;\n  localSha?: string;\n  remoteSha?: string;\n}\n\nexport interface SyncActions {\n  toAdd: SyncAction[];\n  toUpdate: SyncAction[];\n  toDelete: SyncAction[];\n  toSkip: SyncAction[];\n}\n\nexport class PortfolioSyncComparer {\n  /**\n   * Compare GitHub and local elements to determine sync actions\n   */\n  compareElements(\n    githubElements: Map<ElementType, GitHubIndexEntry[]>,\n    localElements: Map<ElementType, any[]>,\n    mode: SyncMode\n  ): SyncActions {\n    const actions: SyncActions = {\n      toAdd: [],\n      toUpdate: [],\n      toDelete: [],\n      toSkip: []\n    };\n\n    logger.info('Comparing elements', { \n      githubCount: this.countElements(githubElements),\n      localCount: this.countElements(localElements),\n      mode \n    });\n\n    // Process each element type\n    const allTypes = new Set([\n      ...githubElements.keys(),\n      ...localElements.keys()\n    ]);\n\n    for (const type of allTypes) {\n      const githubTypeElements = githubElements.get(type) || [];\n      const localTypeElements = localElements.get(type) || [];\n      \n      this.compareTypeElements(\n        type,\n        githubTypeElements,\n        localTypeElements,\n        mode,\n        actions\n      );\n    }\n\n    logger.info('Comparison complete', {\n      toAdd: actions.toAdd.length,\n      toUpdate: actions.toUpdate.length,\n      toDelete: actions.toDelete.length,\n      toSkip: actions.toSkip.length\n    });\n\n    return actions;\n  }\n\n  /**\n   * Compare elements of a specific type\n   */\n  private compareTypeElements(\n    type: ElementType,\n    githubElements: GitHubIndexEntry[],\n    localElements: any[],\n    mode: SyncMode,\n    actions: SyncActions\n  ): void {\n    // Create maps for efficient lookup\n    const githubMap = new Map(\n      githubElements.map(e => [this.normalizeElementName(e.name), e])\n    );\n    const localMap = new Map(\n      localElements.map(e => [this.normalizeElementName(e.name || e.metadata?.name), e])\n    );\n\n    // Process GitHub elements (additions and updates)\n    for (const [name, githubElement] of githubMap) {\n      const localElement = localMap.get(name);\n      \n      if (!localElement) {\n        // Element exists on GitHub but not locally\n        actions.toAdd.push({\n          type,\n          name: githubElement.name,\n          path: githubElement.path,\n          action: 'add',\n          remoteSha: githubElement.sha\n        });\n      } else if (mode === 'backup' || this.shouldUpdate(githubElement, localElement, mode)) {\n        // Element needs updating\n        actions.toUpdate.push({\n          type,\n          name: githubElement.name,\n          path: githubElement.path,\n          action: 'update',\n          reason: mode === 'backup' ? 'backup mode' : 'newer on GitHub',\n          localSha: localElement.sha,\n          remoteSha: githubElement.sha\n        });\n      } else {\n        // Element is up to date or should be skipped\n        actions.toSkip.push({\n          type,\n          name: githubElement.name,\n          path: githubElement.path,\n          action: 'skip',\n          reason: 'up to date',\n          localSha: localElement.sha,\n          remoteSha: githubElement.sha\n        });\n      }\n    }\n\n    // Process local elements (deletions - only in mirror mode)\n    if (mode === 'mirror') {\n      for (const [name, localElement] of localMap) {\n        if (!githubMap.has(name)) {\n          // Element exists locally but not on GitHub\n          actions.toDelete.push({\n            type,\n            name: localElement.name || localElement.metadata?.name || name,\n            path: `${type}/${name}.md`,\n            action: 'delete',\n            reason: 'not on GitHub',\n            localSha: localElement.sha\n          });\n        }\n      }\n    }\n  }\n\n  /**\n   * Determine if an element should be updated\n   */\n  private shouldUpdate(\n    githubElement: GitHubIndexEntry,\n    localElement: any,\n    mode: SyncMode\n  ): boolean {\n    // In backup mode, always update from GitHub\n    if (mode === 'backup') {\n      return true;\n    }\n\n    // In additive mode, never update existing elements\n    if (mode === 'additive') {\n      return false;\n    }\n\n    // In mirror mode, update if SHAs differ\n    // If we don't have SHAs, compare modified dates\n    if (githubElement.sha && localElement.sha) {\n      return githubElement.sha !== localElement.sha;\n    }\n\n    // Compare modified dates if available\n    if (githubElement.lastModified && localElement.lastModified) {\n      const githubDate = new Date(githubElement.lastModified).getTime();\n      const localDate = new Date(localElement.lastModified).getTime();\n      return githubDate > localDate;\n    }\n\n    // If we can't determine, skip updating in mirror mode\n    return false;\n  }\n\n  /**\n   * Normalize element name for comparison\n   * Handles different naming formats and extensions\n   */\n  private normalizeElementName(name: string): string {\n    if (!name) return '';\n    \n    // Remove .md extension if present\n    let normalized = name.replace(/\\.md$/i, '');\n    \n    // Convert to lowercase for comparison\n    normalized = normalized.toLowerCase();\n    \n    // Replace spaces with hyphens (some systems use different formats)\n    normalized = normalized.replace(/\\s+/g, '-');\n    \n    return normalized;\n  }\n\n  /**\n   * Count total elements in a map\n   */\n  private countElements(elements: Map<ElementType, any[]>): number {\n    let count = 0;\n    for (const typeElements of elements.values()) {\n      count += typeElements.length;\n    }\n    return count;\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/dist/utils/TemplateRenderer.d.ts

@@ -0,0 +1,63 @@
+/**
+ * TemplateRenderer - Utility class for rendering templates with comprehensive validation
+ *
+ * IMPROVEMENTS IMPLEMENTED (per Debug Detective recommendations):
+ * 1. instanceof Template verification for type safety
+ * 2. Performance logging to track render times
+ * 3. Validation of render() return value
+ * 4. Clear separation of concerns from index.ts
+ *
+ * This addresses Issues #913 and #914 from the v1.7.3 hotfix
+ */
+import { TemplateManager } from '../elements/templates/TemplateManager.js';
+export interface RenderResult {
+    success: boolean;
+    content?: string;
+    error?: string;
+    performance?: {
+        lookupTime: number;
+        renderTime: number;
+        totalTime: number;
+    };
+}
+export declare class TemplateRenderer {
+    private templateManager;
+    constructor(templateManager: TemplateManager);
+    /**
+     * Render a template with comprehensive validation and performance tracking
+     *
+     * VALIDATION CHAIN:
+     * 1. Unicode normalization of template name
+     * 2. Template exists in manager
+     * 3. Template is proper Template instance
+     * 4. Template has render() method
+     * 5. render() returns a string
+     *
+     * SECURITY:
+     * - Unicode normalization prevents homograph attacks
+     * - Variables are normalized by Template.render() internally
+     *
+     * PERFORMANCE TRACKING:
+     * - Lookup time (finding template)
+     * - Render time (actual rendering)
+     * - Total time (complete operation)
+     */
+    render(name: string, variables?: Record<string, any>): Promise<RenderResult>;
+    /**
+     * Batch render multiple templates (useful for testing)
+     * SECURITY: Each template name is normalized individually
+     */
+    renderBatch(templates: Array<{
+        name: string;
+        variables: Record<string, any>;
+    }>): Promise<Map<string, RenderResult>>;
+    /**
+     * Validate that a template can be rendered without actually rendering it
+     * SECURITY: Template name is normalized to prevent Unicode attacks
+     */
+    validate(name: string): Promise<{
+        valid: boolean;
+        reason?: string;
+    }>;
+}
+//# sourceMappingURL=TemplateRenderer.d.ts.map

package/dist/utils/TemplateRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TemplateRenderer.d.ts","sourceRoot":"","sources":["../../src/utils/TemplateRenderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,0CAA0C,CAAC;AAI3E,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE;QACZ,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAED,qBAAa,gBAAgB;IACf,OAAO,CAAC,eAAe;gBAAf,eAAe,EAAE,eAAe;IAEpD;;;;;;;;;;;;;;;;;;OAkBG;IACG,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAkGtF;;;OAGG;IACG,WAAW,CACf,SAAS,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAAE,CAAC,GACjE,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAWrC;;;OAGG;IACG,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CA4B3E"}