@dollhousemcp/mcp-server 1.7.1 → 1.7.3

package/dist/generated/version.d.ts

@@ -2,8 +2,8 @@
  * Auto-generated file - DO NOT EDIT
  * Generated at build time by scripts/generate-version.js
  */
-export declare const PACKAGE_VERSION = "1.7.1";
-export declare const BUILD_TIMESTAMP = "2025-08-31T23:09:37.090Z";
+export declare const PACKAGE_VERSION = "1.7.3";
+export declare const BUILD_TIMESTAMP = "2025-09-09T19:23:32.095Z";
 export declare const BUILD_TYPE: 'npm' | 'git';
 export declare const PACKAGE_NAME = "@dollhousemcp/mcp-server";
 //# sourceMappingURL=version.d.ts.map

package/dist/generated/version.js

@@ -2,8 +2,8 @@
  * Auto-generated file - DO NOT EDIT
  * Generated at build time by scripts/generate-version.js
  */
-export const PACKAGE_VERSION = '1.7.1';
-export const BUILD_TIMESTAMP = '2025-08-31T23:09:37.090Z';
+export const PACKAGE_VERSION = '1.7.3';
+export const BUILD_TIMESTAMP = '2025-09-09T19:23:32.095Z';
 export const BUILD_TYPE = 'npm';
 export const PACKAGE_NAME = '@dollhousemcp/mcp-server';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9nZW5lcmF0ZWQvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsT0FBTyxDQUFDO0FBQ3ZDLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRywwQkFBMEIsQ0FBQztBQUMxRCxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQWtCLEtBQUssQ0FBQztBQUMvQyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEF1dG8tZ2VuZXJhdGVkIGZpbGUgLSBETyBOT1QgRURJVFxuICogR2VuZXJhdGVkIGF0IGJ1aWxkIHRpbWUgYnkgc2NyaXB0cy9nZW5lcmF0ZS12ZXJzaW9uLmpzXG4gKi9cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfVkVSU0lPTiA9ICcxLjcuMSc7XG5leHBvcnQgY29uc3QgQlVJTERfVElNRVNUQU1QID0gJzIwMjUtMDgtMzFUMjM6MDk6MzcuMDkwWic7XG5leHBvcnQgY29uc3QgQlVJTERfVFlQRTogJ25wbScgfCAnZ2l0JyA9ICducG0nO1xuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfTkFNRSA9ICdAZG9sbGhvdXNlbWNwL21jcC1zZXJ2ZXInO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9nZW5lcmF0ZWQvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsT0FBTyxDQUFDO0FBQ3ZDLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRywwQkFBMEIsQ0FBQztBQUMxRCxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQWtCLEtBQUssQ0FBQztBQUMvQyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEF1dG8tZ2VuZXJhdGVkIGZpbGUgLSBETyBOT1QgRURJVFxuICogR2VuZXJhdGVkIGF0IGJ1aWxkIHRpbWUgYnkgc2NyaXB0cy9nZW5lcmF0ZS12ZXJzaW9uLmpzXG4gKi9cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfVkVSU0lPTiA9ICcxLjcuMyc7XG5leHBvcnQgY29uc3QgQlVJTERfVElNRVNUQU1QID0gJzIwMjUtMDktMDlUMTk6MjM6MzIuMDk1Wic7XG5leHBvcnQgY29uc3QgQlVJTERfVFlQRTogJ25wbScgfCAnZ2l0JyA9ICducG0nO1xuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfTkFNRSA9ICdAZG9sbGhvdXNlbWNwL21jcC1zZXJ2ZXInO1xuIl19

package/dist/handlers/ConfigHandler.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Configuration handler for the dollhouse_config MCP tool
+ * Provides unified interface for all configuration management operations
+ */
+export interface ConfigOperationOptions {
+    action: 'get' | 'set' | 'reset' | 'export' | 'import' | 'wizard';
+    setting?: string;
+    value?: any;
+    section?: string;
+    format?: 'yaml' | 'json';
+    data?: string;
+}
+export declare class ConfigHandler {
+    private configManager;
+    constructor();
+    /**
+     * Handle configuration operations via the dollhouse_config tool
+     */
+    handleConfigOperation(options: ConfigOperationOptions, indicator?: string): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    private handleGet;
+    private handleSet;
+    private handleReset;
+    private handleExport;
+    private handleImport;
+    private handleWizard;
+}
+//# sourceMappingURL=ConfigHandler.d.ts.map

package/dist/handlers/ConfigHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigHandler.d.ts","sourceRoot":"","sources":["../../src/handlers/ConfigHandler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,KAAK,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACjE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,aAAa,CAAgB;;IAMrC;;OAEG;IACG,qBAAqB,CAAC,OAAO,EAAE,sBAAsB,EAAE,SAAS,GAAE,MAAW;;;;;;YA4CrE,SAAS;YAkCT,SAAS;YA2CT,WAAW;YAyBX,YAAY;YAeZ,YAAY;IAuB1B,OAAO,CAAC,YAAY;CAsBrB"}

package/dist/handlers/ConfigHandler.js

@@ -0,0 +1,202 @@
+/**
+ * Configuration handler for the dollhouse_config MCP tool
+ * Provides unified interface for all configuration management operations
+ */
+import { ConfigManager } from '../config/ConfigManager.js';
+import { SecureErrorHandler } from '../security/errorHandler.js';
+import * as yaml from 'js-yaml';
+export class ConfigHandler {
+    configManager;
+    constructor() {
+        this.configManager = ConfigManager.getInstance();
+    }
+    /**
+     * Handle configuration operations via the dollhouse_config tool
+     */
+    async handleConfigOperation(options, indicator = '') {
+        try {
+            await this.configManager.initialize();
+            switch (options.action) {
+                case 'get':
+                    return this.handleGet(options, indicator);
+                case 'set':
+                    return this.handleSet(options, indicator);
+                case 'reset':
+                    return this.handleReset(options, indicator);
+                case 'export':
+                    return this.handleExport(options, indicator);
+                case 'import':
+                    return this.handleImport(options, indicator);
+                case 'wizard':
+                    return this.handleWizard(indicator);
+                default:
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `${indicator}❌ Invalid action '${options.action}'.\n\n` +
+                                    `Valid actions: get, set, reset, export, import, wizard`
+                            }]
+                    };
+            }
+        }
+        catch (error) {
+            const sanitizedError = SecureErrorHandler.sanitizeError(error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `${indicator}❌ Configuration operation failed: ${sanitizedError.message}`
+                    }]
+            };
+        }
+    }
+    async handleGet(options, indicator) {
+        // Get a specific setting or all settings
+        if (options.setting) {
+            const value = this.configManager.getSetting(options.setting);
+            if (value === undefined) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `${indicator}❌ Setting '${options.setting}' not found.\n\n` +
+                                `Use \`dollhouse_config action: "get"\` to see all available settings.`
+                        }]
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `${indicator}⚙️ **Configuration Setting**\n\n` +
+                            `**${options.setting}**: ${JSON.stringify(value, null, 2)}`
+                    }]
+            };
+        }
+        // Get all settings
+        const config = this.configManager.getConfig();
+        return {
+            content: [{
+                    type: "text",
+                    text: `${indicator}⚙️ **DollhouseMCP Configuration**\n\n` +
+                        `\`\`\`yaml\n${yaml.dump(config, { lineWidth: -1 })}\`\`\``
+                }]
+        };
+    }
+    async handleSet(options, indicator) {
+        // Set a configuration value
+        if (!options.setting || options.value === undefined) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `${indicator}❌ Both 'setting' and 'value' are required for set operation.\n\n` +
+                            `Example: \`dollhouse_config action: "set", setting: "sync.enabled", value: true\``
+                    }]
+            };
+        }
+        // Type coercion for common string-to-type conversions
+        let coercedValue = options.value;
+        // Convert string booleans to actual booleans
+        if (typeof coercedValue === 'string') {
+            const lowerValue = coercedValue.toLowerCase();
+            if (lowerValue === 'true') {
+                coercedValue = true;
+            }
+            else if (lowerValue === 'false') {
+                coercedValue = false;
+            }
+            else if (/^\d+$/.test(coercedValue)) {
+                // Convert numeric strings to numbers
+                const numValue = parseInt(coercedValue, 10);
+                if (!isNaN(numValue)) {
+                    coercedValue = numValue;
+                }
+            }
+        }
+        await this.configManager.updateSetting(options.setting, coercedValue);
+        return {
+            content: [{
+                    type: "text",
+                    text: `${indicator}✅ **Configuration Updated**\n\n` +
+                        `**${options.setting}** set to: ${JSON.stringify(coercedValue, null, 2)}\n\n` +
+                        `Changes have been saved to the configuration file.`
+                }]
+        };
+    }
+    async handleReset(options, indicator) {
+        // Reset configuration to defaults
+        if (options.section) {
+            await this.configManager.resetConfig(options.section);
+            return {
+                content: [{
+                        type: "text",
+                        text: `${indicator}🔄 **Configuration Reset**\n\n` +
+                            `Section '${options.section}' has been reset to default values.`
+                    }]
+            };
+        }
+        // Reset all configuration
+        await this.configManager.resetConfig();
+        return {
+            content: [{
+                    type: "text",
+                    text: `${indicator}🔄 **Configuration Reset**\n\n` +
+                        `All settings have been reset to default values.\n\n` +
+                        `Note: User identity and GitHub authentication are preserved.`
+                }]
+        };
+    }
+    async handleExport(options, indicator) {
+        // Export configuration
+        const format = options.format || 'yaml';
+        const exported = await this.configManager.exportConfig(format);
+        return {
+            content: [{
+                    type: "text",
+                    text: `${indicator}📤 **Configuration Export**\n\n` +
+                        `\`\`\`${format}\n${exported}\`\`\`\n\n` +
+                        `You can save this configuration and import it later.`
+                }]
+        };
+    }
+    async handleImport(options, indicator) {
+        // Import configuration
+        if (!options.data) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `${indicator}❌ Configuration data is required for import.\n\n` +
+                            `Provide YAML or JSON configuration in the 'data' parameter.`
+                    }]
+            };
+        }
+        await this.configManager.importConfig(options.data);
+        return {
+            content: [{
+                    type: "text",
+                    text: `${indicator}✅ **Configuration Imported**\n\n` +
+                        `Configuration has been successfully imported and saved.`
+                }]
+        };
+    }
+    handleWizard(indicator) {
+        // Interactive configuration wizard
+        return {
+            content: [{
+                    type: "text",
+                    text: `${indicator}🧙 **Configuration Wizard**\n\n` +
+                        `The configuration wizard helps you set up DollhouseMCP.\n\n` +
+                        `**Key Settings to Configure:**\n\n` +
+                        `1. **User Identity**\n` +
+                        `   \`dollhouse_config action: "set", setting: "user.username", value: "your-username"\`\n\n` +
+                        `2. **GitHub Portfolio**\n` +
+                        `   \`dollhouse_config action: "set", setting: "github.portfolio.repository_name", value: "dollhouse-portfolio"\`\n\n` +
+                        `3. **Sync Settings**\n` +
+                        `   \`dollhouse_config action: "set", setting: "sync.enabled", value: true\`\n` +
+                        `   \`dollhouse_config action: "set", setting: "sync.bulk.upload_enabled", value: true\`\n\n` +
+                        `4. **Privacy Settings**\n` +
+                        `   \`dollhouse_config action: "set", setting: "sync.privacy.scan_for_secrets", value: true\`\n` +
+                        `   \`dollhouse_config action: "set", setting: "sync.privacy.respect_local_only", value: true\`\n\n` +
+                        `Run \`dollhouse_config action: "get"\` to see current settings.`
+                }]
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ConfigHandler.js","sourceRoot":"","sources":["../../src/handlers/ConfigHandler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Configuration handler for the dollhouse_config MCP tool\n * Provides unified interface for all configuration management operations\n */\n\nimport { ConfigManager } from '../config/ConfigManager.js';\nimport { SecureErrorHandler } from '../security/errorHandler.js';\nimport * as yaml from 'js-yaml';\n\nexport interface ConfigOperationOptions {\n  action: 'get' | 'set' | 'reset' | 'export' | 'import' | 'wizard';\n  setting?: string;\n  value?: any;\n  section?: string;\n  format?: 'yaml' | 'json';\n  data?: string;\n}\n\nexport class ConfigHandler {\n  private configManager: ConfigManager;\n  \n  constructor() {\n    this.configManager = ConfigManager.getInstance();\n  }\n  \n  /**\n   * Handle configuration operations via the dollhouse_config tool\n   */\n  async handleConfigOperation(options: ConfigOperationOptions, indicator: string = '') {\n    try {\n      await this.configManager.initialize();\n      \n      switch (options.action) {\n        case 'get':\n          return this.handleGet(options, indicator);\n        \n        case 'set':\n          return this.handleSet(options, indicator);\n        \n        case 'reset':\n          return this.handleReset(options, indicator);\n        \n        case 'export':\n          return this.handleExport(options, indicator);\n        \n        case 'import':\n          return this.handleImport(options, indicator);\n        \n        case 'wizard':\n          return this.handleWizard(indicator);\n        \n        default:\n          return {\n            content: [{\n              type: \"text\",\n              text: `${indicator}❌ Invalid action '${options.action}'.\\n\\n` +\n                    `Valid actions: get, set, reset, export, import, wizard`\n            }]\n          };\n      }\n      \n    } catch (error) {\n      const sanitizedError = SecureErrorHandler.sanitizeError(error);\n      return {\n        content: [{\n          type: \"text\",\n          text: `${indicator}❌ Configuration operation failed: ${sanitizedError.message}`\n        }]\n      };\n    }\n  }\n  \n  private async handleGet(options: ConfigOperationOptions, indicator: string) {\n    // Get a specific setting or all settings\n    if (options.setting) {\n      const value = this.configManager.getSetting(options.setting);\n      if (value === undefined) {\n        return {\n          content: [{\n            type: \"text\",\n            text: `${indicator}❌ Setting '${options.setting}' not found.\\n\\n` +\n                  `Use \\`dollhouse_config action: \"get\"\\` to see all available settings.`\n          }]\n        };\n      }\n      \n      return {\n        content: [{\n          type: \"text\",\n          text: `${indicator}⚙️ **Configuration Setting**\\n\\n` +\n                `**${options.setting}**: ${JSON.stringify(value, null, 2)}`\n        }]\n      };\n    }\n    \n    // Get all settings\n    const config = this.configManager.getConfig();\n    return {\n      content: [{\n        type: \"text\",\n        text: `${indicator}⚙️ **DollhouseMCP Configuration**\\n\\n` +\n              `\\`\\`\\`yaml\\n${yaml.dump(config, { lineWidth: -1 })}\\`\\`\\``\n      }]\n    };\n  }\n  \n  private async handleSet(options: ConfigOperationOptions, indicator: string) {\n    // Set a configuration value\n    if (!options.setting || options.value === undefined) {\n      return {\n        content: [{\n          type: \"text\",\n          text: `${indicator}❌ Both 'setting' and 'value' are required for set operation.\\n\\n` +\n                `Example: \\`dollhouse_config action: \"set\", setting: \"sync.enabled\", value: true\\``\n        }]\n      };\n    }\n    \n    // Type coercion for common string-to-type conversions\n    let coercedValue = options.value;\n    \n    // Convert string booleans to actual booleans\n    if (typeof coercedValue === 'string') {\n      const lowerValue = coercedValue.toLowerCase();\n      if (lowerValue === 'true') {\n        coercedValue = true;\n      } else if (lowerValue === 'false') {\n        coercedValue = false;\n      } else if (/^\\d+$/.test(coercedValue)) {\n        // Convert numeric strings to numbers\n        const numValue = parseInt(coercedValue, 10);\n        if (!isNaN(numValue)) {\n          coercedValue = numValue;\n        }\n      }\n    }\n    \n    await this.configManager.updateSetting(options.setting, coercedValue);\n    \n    return {\n      content: [{\n        type: \"text\",\n        text: `${indicator}✅ **Configuration Updated**\\n\\n` +\n              `**${options.setting}** set to: ${JSON.stringify(coercedValue, null, 2)}\\n\\n` +\n              `Changes have been saved to the configuration file.`\n      }]\n    };\n  }\n  \n  private async handleReset(options: ConfigOperationOptions, indicator: string) {\n    // Reset configuration to defaults\n    if (options.section) {\n      await this.configManager.resetConfig(options.section);\n      return {\n        content: [{\n          type: \"text\",\n          text: `${indicator}🔄 **Configuration Reset**\\n\\n` +\n                `Section '${options.section}' has been reset to default values.`\n        }]\n      };\n    }\n    \n    // Reset all configuration\n    await this.configManager.resetConfig();\n    return {\n      content: [{\n        type: \"text\",\n        text: `${indicator}🔄 **Configuration Reset**\\n\\n` +\n              `All settings have been reset to default values.\\n\\n` +\n              `Note: User identity and GitHub authentication are preserved.`\n      }]\n    };\n  }\n  \n  private async handleExport(options: ConfigOperationOptions, indicator: string) {\n    // Export configuration\n    const format = options.format || 'yaml';\n    const exported = await this.configManager.exportConfig(format);\n    \n    return {\n      content: [{\n        type: \"text\",\n        text: `${indicator}📤 **Configuration Export**\\n\\n` +\n              `\\`\\`\\`${format}\\n${exported}\\`\\`\\`\\n\\n` +\n              `You can save this configuration and import it later.`\n      }]\n    };\n  }\n  \n  private async handleImport(options: ConfigOperationOptions, indicator: string) {\n    // Import configuration\n    if (!options.data) {\n      return {\n        content: [{\n          type: \"text\",\n          text: `${indicator}❌ Configuration data is required for import.\\n\\n` +\n                `Provide YAML or JSON configuration in the 'data' parameter.`\n        }]\n      };\n    }\n    \n    await this.configManager.importConfig(options.data);\n    \n    return {\n      content: [{\n        type: \"text\",\n        text: `${indicator}✅ **Configuration Imported**\\n\\n` +\n              `Configuration has been successfully imported and saved.`\n      }]\n    };\n  }\n  \n  private handleWizard(indicator: string) {\n    // Interactive configuration wizard\n    return {\n      content: [{\n        type: \"text\",\n        text: `${indicator}🧙 **Configuration Wizard**\\n\\n` +\n              `The configuration wizard helps you set up DollhouseMCP.\\n\\n` +\n              `**Key Settings to Configure:**\\n\\n` +\n              `1. **User Identity**\\n` +\n              `   \\`dollhouse_config action: \"set\", setting: \"user.username\", value: \"your-username\"\\`\\n\\n` +\n              `2. **GitHub Portfolio**\\n` +\n              `   \\`dollhouse_config action: \"set\", setting: \"github.portfolio.repository_name\", value: \"dollhouse-portfolio\"\\`\\n\\n` +\n              `3. **Sync Settings**\\n` +\n              `   \\`dollhouse_config action: \"set\", setting: \"sync.enabled\", value: true\\`\\n` +\n              `   \\`dollhouse_config action: \"set\", setting: \"sync.bulk.upload_enabled\", value: true\\`\\n\\n` +\n              `4. **Privacy Settings**\\n` +\n              `   \\`dollhouse_config action: \"set\", setting: \"sync.privacy.scan_for_secrets\", value: true\\`\\n` +\n              `   \\`dollhouse_config action: \"set\", setting: \"sync.privacy.respect_local_only\", value: true\\`\\n\\n` +\n              `Run \\`dollhouse_config action: \"get\"\\` to see current settings.`\n      }]\n    };\n  }\n}"]}

package/dist/handlers/SyncHandlerV2.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Portfolio sync handler for the sync_portfolio MCP tool
+ * Manages bi-directional synchronization between local portfolio and GitHub
+ * This V2 version works with the actual PortfolioSyncManager implementation
+ */
+import { ElementType } from '../portfolio/PortfolioManager.js';
+export interface SyncOperationOptions {
+    operation: 'list-remote' | 'download' | 'upload' | 'compare' | 'bulk-download' | 'bulk-upload';
+    element_name?: string;
+    element_type?: ElementType;
+    filter?: {
+        type?: ElementType;
+        author?: string;
+        updated_after?: string;
+    };
+    options?: {
+        force?: boolean;
+        dry_run?: boolean;
+        include_private?: boolean;
+    };
+}
+export declare class SyncHandler {
+    private syncManager;
+    private configManager;
+    constructor();
+    /**
+     * Handle portfolio sync operations
+     */
+    handleSyncOperation(options: SyncOperationOptions, indicator?: string): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    private mapOperation;
+    private formatResult;
+    private formatListResult;
+    private formatDownloadResult;
+    private formatUploadResult;
+    private formatCompareResult;
+}
+//# sourceMappingURL=SyncHandlerV2.d.ts.map

package/dist/handlers/SyncHandlerV2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SyncHandlerV2.d.ts","sourceRoot":"","sources":["../../src/handlers/SyncHandlerV2.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAG/D,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,aAAa,GAAG,UAAU,GAAG,QAAQ,GAAG,SAAS,GAAG,eAAe,GAAG,aAAa,CAAC;IAC/F,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B,MAAM,CAAC,EAAE;QACP,IAAI,CAAC,EAAE,WAAW,CAAC;QACnB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;IACF,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,eAAe,CAAC,EAAE,OAAO,CAAC;KAC3B,CAAC;CACH;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,aAAa,CAAgB;;IAOrC;;OAEG;IACG,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,EAAE,SAAS,GAAE,MAAW;;;;;;IAgD/E,OAAO,CAAC,YAAY;IAiBpB,OAAO,CAAC,YAAY;IAmCpB,OAAO,CAAC,gBAAgB;IAgDxB,OAAO,CAAC,oBAAoB;IA2B5B,OAAO,CAAC,kBAAkB;IA2B1B,OAAO,CAAC,mBAAmB;CAmC5B"}

package/dist/handlers/SyncHandlerV2.js

@@ -0,0 +1,231 @@
+/**
+ * Portfolio sync handler for the sync_portfolio MCP tool
+ * Manages bi-directional synchronization between local portfolio and GitHub
+ * This V2 version works with the actual PortfolioSyncManager implementation
+ */
+import { PortfolioSyncManager } from '../portfolio/PortfolioSyncManager.js';
+import { ConfigManager } from '../config/ConfigManager.js';
+import { SecureErrorHandler } from '../security/errorHandler.js';
+export class SyncHandler {
+    syncManager;
+    configManager;
+    constructor() {
+        this.syncManager = new PortfolioSyncManager();
+        this.configManager = ConfigManager.getInstance();
+    }
+    /**
+     * Handle portfolio sync operations
+     */
+    async handleSyncOperation(options, indicator = '') {
+        try {
+            await this.configManager.initialize();
+            // Check if sync is enabled (allow list-remote and compare even when disabled)
+            const syncEnabled = this.configManager.getSetting('sync.enabled');
+            const readOnlyOperations = ['list-remote', 'compare'];
+            if (!syncEnabled && !readOnlyOperations.includes(options.operation)) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `${indicator}⚠️ **Sync is Disabled**\n\n` +
+                                `Portfolio sync is currently disabled for privacy.\n\n` +
+                                `To enable sync:\n` +
+                                `\`dollhouse_config action: "set", setting: "sync.enabled", value: true\`\n\n` +
+                                `You can still use \`list-remote\` and \`compare\` to view differences.`
+                        }]
+                };
+            }
+            // Map our operation to PortfolioSyncManager's SyncOperation format
+            const syncOp = {
+                operation: this.mapOperation(options.operation),
+                element_name: options.element_name,
+                element_type: options.element_type || options.filter?.type, // Use filter.type if element_type not provided
+                bulk: options.operation.includes('bulk'),
+                show_diff: options.operation === 'compare',
+                force: options.options?.force,
+                confirm: options.options?.force || options.options?.dry_run === false // force implies confirm, dry_run=false means confirm
+            };
+            // Call the unified handleSyncOperation method
+            const result = await this.syncManager.handleSyncOperation(syncOp);
+            // Format the result based on the operation type
+            return this.formatResult(result, options, indicator);
+        }
+        catch (error) {
+            const sanitizedError = SecureErrorHandler.sanitizeError(error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `${indicator}❌ Sync operation failed: ${sanitizedError.message}`
+                    }]
+            };
+        }
+    }
+    mapOperation(operation) {
+        switch (operation) {
+            case 'list-remote':
+                return 'list-remote';
+            case 'download':
+            case 'bulk-download':
+                return 'download';
+            case 'upload':
+            case 'bulk-upload':
+                return 'upload';
+            case 'compare':
+                return 'compare';
+            default:
+                return 'list-remote';
+        }
+    }
+    formatResult(result, options, indicator) {
+        if (!result.success) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `${indicator}❌ ${result.message}`
+                    }]
+            };
+        }
+        switch (options.operation) {
+            case 'list-remote':
+                return this.formatListResult(result, indicator);
+            case 'download':
+            case 'bulk-download':
+                return this.formatDownloadResult(result, options, indicator);
+            case 'upload':
+            case 'bulk-upload':
+                return this.formatUploadResult(result, options, indicator);
+            case 'compare':
+                return this.formatCompareResult(result, options, indicator);
+            default:
+                return {
+                    content: [{
+                            type: "text",
+                            text: `${indicator}✅ ${result.message}`
+                        }]
+                };
+        }
+    }
+    formatListResult(result, indicator) {
+        if (!result.elements || result.elements.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `${indicator}📋 **GitHub Portfolio is Empty**\n\n` +
+                            `No elements found in your GitHub portfolio.\n\n` +
+                            `Upload elements using:\n` +
+                            `\`sync_portfolio operation: "upload", element_name: "name", element_type: "type"\``
+                    }]
+            };
+        }
+        let text = `${indicator}📋 **GitHub Portfolio Contents**\n\n`;
+        text += `Found ${result.elements.length} elements:\n\n`;
+        // Group by type
+        const byType = {};
+        for (const element of result.elements) {
+            if (!byType[element.type]) {
+                byType[element.type] = [];
+            }
+            byType[element.type].push(element);
+        }
+        for (const [type, elements] of Object.entries(byType)) {
+            text += `**${type}** (${elements.length}):\n`;
+            for (const element of elements) {
+                text += `  • ${element.name}`;
+                if (element.remoteVersion) {
+                    text += ` v${element.remoteVersion}`;
+                }
+                if (element.status) {
+                    text += ` (${element.status})`;
+                }
+                text += '\n';
+            }
+            text += '\n';
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text
+                }]
+        };
+    }
+    formatDownloadResult(result, options, indicator) {
+        if (options.operation === 'bulk-download') {
+            const elements = result.elements || [];
+            const downloaded = elements.filter(e => e.action === 'download').length;
+            const skipped = elements.filter(e => e.action === 'skip').length;
+            return {
+                content: [{
+                        type: "text",
+                        text: `${indicator}✅ **Bulk Download Complete**\n\n` +
+                            `Downloaded: ${downloaded} elements\n` +
+                            `Skipped: ${skipped} elements\n\n` +
+                            result.message
+                    }]
+            };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `${indicator}✅ **Element Downloaded**\n\n` +
+                        `Element: ${options.element_name} (${options.element_type})\n\n` +
+                        result.message
+                }]
+        };
+    }
+    formatUploadResult(result, options, indicator) {
+        if (options.operation === 'bulk-upload') {
+            const elements = result.elements || [];
+            const uploaded = elements.filter(e => e.action === 'upload').length;
+            const skipped = elements.filter(e => e.action === 'skip').length;
+            return {
+                content: [{
+                        type: "text",
+                        text: `${indicator}✅ **Bulk Upload Complete**\n\n` +
+                            `Uploaded: ${uploaded} elements\n` +
+                            `Skipped: ${skipped} elements\n\n` +
+                            result.message
+                    }]
+            };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `${indicator}✅ **Element Uploaded**\n\n` +
+                        `Element: ${options.element_name} (${options.element_type})\n\n` +
+                        result.message
+                }]
+        };
+    }
+    formatCompareResult(result, options, indicator) {
+        let text = `${indicator}🔍 **Version Comparison**\n\n`;
+        text += `Element: ${options.element_name} (${options.element_type})\n\n`;
+        if (result.data) {
+            // If we have detailed comparison data
+            const data = result.data;
+            if (data.local) {
+                text += `**Local Version**: ${data.local.version}\n`;
+                text += `  Modified: ${new Date(data.local.timestamp).toLocaleString()}\n`;
+            }
+            else {
+                text += `**Local Version**: Not found\n`;
+            }
+            if (data.remote) {
+                text += `\n**Remote Version**: ${data.remote.version}\n`;
+                text += `  Modified: ${new Date(data.remote.timestamp).toLocaleString()}\n`;
+            }
+            else {
+                text += `\n**Remote Version**: Not found\n`;
+            }
+            if (data.diff) {
+                text += `\n**Differences**:\n${data.diff}`;
+            }
+        }
+        text += `\n\n${result.message}`;
+        return {
+            content: [{
+                    type: "text",
+                    text
+                }]
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SyncHandlerV2.js","sourceRoot":"","sources":["../../src/handlers/SyncHandlerV2.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Portfolio sync handler for the sync_portfolio MCP tool\n * Manages bi-directional synchronization between local portfolio and GitHub\n * This V2 version works with the actual PortfolioSyncManager implementation\n */\n\nimport { PortfolioSyncManager, SyncOperation, SyncResult } from '../portfolio/PortfolioSyncManager.js';\nimport { ConfigManager } from '../config/ConfigManager.js';\nimport { SecureErrorHandler } from '../security/errorHandler.js';\nimport { ElementType } from '../portfolio/PortfolioManager.js';\nimport { logger } from '../utils/logger.js';\n\nexport interface SyncOperationOptions {\n  operation: 'list-remote' | 'download' | 'upload' | 'compare' | 'bulk-download' | 'bulk-upload';\n  element_name?: string;\n  element_type?: ElementType;\n  filter?: {\n    type?: ElementType;\n    author?: string;\n    updated_after?: string;\n  };\n  options?: {\n    force?: boolean;\n    dry_run?: boolean;\n    include_private?: boolean;\n  };\n}\n\nexport class SyncHandler {\n  private syncManager: PortfolioSyncManager;\n  private configManager: ConfigManager;\n  \n  constructor() {\n    this.syncManager = new PortfolioSyncManager();\n    this.configManager = ConfigManager.getInstance();\n  }\n  \n  /**\n   * Handle portfolio sync operations\n   */\n  async handleSyncOperation(options: SyncOperationOptions, indicator: string = '') {\n    try {\n      await this.configManager.initialize();\n      \n      // Check if sync is enabled (allow list-remote and compare even when disabled)\n      const syncEnabled = this.configManager.getSetting('sync.enabled');\n      const readOnlyOperations = ['list-remote', 'compare'];\n      if (!syncEnabled && !readOnlyOperations.includes(options.operation)) {\n        return {\n          content: [{\n            type: \"text\",\n            text: `${indicator}⚠️ **Sync is Disabled**\\n\\n` +\n                  `Portfolio sync is currently disabled for privacy.\\n\\n` +\n                  `To enable sync:\\n` +\n                  `\\`dollhouse_config action: \"set\", setting: \"sync.enabled\", value: true\\`\\n\\n` +\n                  `You can still use \\`list-remote\\` and \\`compare\\` to view differences.`\n          }]\n        };\n      }\n      \n      // Map our operation to PortfolioSyncManager's SyncOperation format\n      const syncOp: SyncOperation = {\n        operation: this.mapOperation(options.operation),\n        element_name: options.element_name,\n        element_type: options.element_type || options.filter?.type, // Use filter.type if element_type not provided\n        bulk: options.operation.includes('bulk'),\n        show_diff: options.operation === 'compare',\n        force: options.options?.force,\n        confirm: options.options?.force || options.options?.dry_run === false // force implies confirm, dry_run=false means confirm\n      };\n      \n      // Call the unified handleSyncOperation method\n      const result = await this.syncManager.handleSyncOperation(syncOp);\n      \n      // Format the result based on the operation type\n      return this.formatResult(result, options, indicator);\n      \n    } catch (error) {\n      const sanitizedError = SecureErrorHandler.sanitizeError(error);\n      return {\n        content: [{\n          type: \"text\",\n          text: `${indicator}❌ Sync operation failed: ${sanitizedError.message}`\n        }]\n      };\n    }\n  }\n  \n  private mapOperation(operation: string): 'download' | 'upload' | 'compare' | 'list-remote' {\n    switch (operation) {\n      case 'list-remote':\n        return 'list-remote';\n      case 'download':\n      case 'bulk-download':\n        return 'download';\n      case 'upload':\n      case 'bulk-upload':\n        return 'upload';\n      case 'compare':\n        return 'compare';\n      default:\n        return 'list-remote';\n    }\n  }\n  \n  private formatResult(result: SyncResult, options: SyncOperationOptions, indicator: string) {\n    if (!result.success) {\n      return {\n        content: [{\n          type: \"text\",\n          text: `${indicator}❌ ${result.message}`\n        }]\n      };\n    }\n    \n    switch (options.operation) {\n      case 'list-remote':\n        return this.formatListResult(result, indicator);\n      \n      case 'download':\n      case 'bulk-download':\n        return this.formatDownloadResult(result, options, indicator);\n      \n      case 'upload':\n      case 'bulk-upload':\n        return this.formatUploadResult(result, options, indicator);\n      \n      case 'compare':\n        return this.formatCompareResult(result, options, indicator);\n      \n      default:\n        return {\n          content: [{\n            type: \"text\",\n            text: `${indicator}✅ ${result.message}`\n          }]\n        };\n    }\n  }\n  \n  private formatListResult(result: SyncResult, indicator: string) {\n    if (!result.elements || result.elements.length === 0) {\n      return {\n        content: [{\n          type: \"text\",\n          text: `${indicator}📋 **GitHub Portfolio is Empty**\\n\\n` +\n                `No elements found in your GitHub portfolio.\\n\\n` +\n                `Upload elements using:\\n` +\n                `\\`sync_portfolio operation: \"upload\", element_name: \"name\", element_type: \"type\"\\``\n        }]\n      };\n    }\n    \n    let text = `${indicator}📋 **GitHub Portfolio Contents**\\n\\n`;\n    text += `Found ${result.elements.length} elements:\\n\\n`;\n    \n    // Group by type\n    const byType: Record<string, any[]> = {};\n    for (const element of result.elements) {\n      if (!byType[element.type]) {\n        byType[element.type] = [];\n      }\n      byType[element.type].push(element);\n    }\n    \n    for (const [type, elements] of Object.entries(byType)) {\n      text += `**${type}** (${elements.length}):\\n`;\n      for (const element of elements) {\n        text += `  • ${element.name}`;\n        if (element.remoteVersion) {\n          text += ` v${element.remoteVersion}`;\n        }\n        if (element.status) {\n          text += ` (${element.status})`;\n        }\n        text += '\\n';\n      }\n      text += '\\n';\n    }\n    \n    return {\n      content: [{\n        type: \"text\",\n        text\n      }]\n    };\n  }\n  \n  private formatDownloadResult(result: SyncResult, options: SyncOperationOptions, indicator: string) {\n    if (options.operation === 'bulk-download') {\n      const elements = result.elements || [];\n      const downloaded = elements.filter(e => e.action === 'download').length;\n      const skipped = elements.filter(e => e.action === 'skip').length;\n      \n      return {\n        content: [{\n          type: \"text\",\n          text: `${indicator}✅ **Bulk Download Complete**\\n\\n` +\n                `Downloaded: ${downloaded} elements\\n` +\n                `Skipped: ${skipped} elements\\n\\n` +\n                result.message\n        }]\n      };\n    }\n    \n    return {\n      content: [{\n        type: \"text\",\n        text: `${indicator}✅ **Element Downloaded**\\n\\n` +\n              `Element: ${options.element_name} (${options.element_type})\\n\\n` +\n              result.message\n      }]\n    };\n  }\n  \n  private formatUploadResult(result: SyncResult, options: SyncOperationOptions, indicator: string) {\n    if (options.operation === 'bulk-upload') {\n      const elements = result.elements || [];\n      const uploaded = elements.filter(e => e.action === 'upload').length;\n      const skipped = elements.filter(e => e.action === 'skip').length;\n      \n      return {\n        content: [{\n          type: \"text\",\n          text: `${indicator}✅ **Bulk Upload Complete**\\n\\n` +\n                `Uploaded: ${uploaded} elements\\n` +\n                `Skipped: ${skipped} elements\\n\\n` +\n                result.message\n        }]\n      };\n    }\n    \n    return {\n      content: [{\n        type: \"text\",\n        text: `${indicator}✅ **Element Uploaded**\\n\\n` +\n              `Element: ${options.element_name} (${options.element_type})\\n\\n` +\n              result.message\n      }]\n    };\n  }\n  \n  private formatCompareResult(result: SyncResult, options: SyncOperationOptions, indicator: string) {\n    let text = `${indicator}🔍 **Version Comparison**\\n\\n`;\n    text += `Element: ${options.element_name} (${options.element_type})\\n\\n`;\n    \n    if (result.data) {\n      // If we have detailed comparison data\n      const data = result.data;\n      if (data.local) {\n        text += `**Local Version**: ${data.local.version}\\n`;\n        text += `  Modified: ${new Date(data.local.timestamp).toLocaleString()}\\n`;\n      } else {\n        text += `**Local Version**: Not found\\n`;\n      }\n      \n      if (data.remote) {\n        text += `\\n**Remote Version**: ${data.remote.version}\\n`;\n        text += `  Modified: ${new Date(data.remote.timestamp).toLocaleString()}\\n`;\n      } else {\n        text += `\\n**Remote Version**: Not found\\n`;\n      }\n      \n      if (data.diff) {\n        text += `\\n**Differences**:\\n${data.diff}`;\n      }\n    }\n    \n    text += `\\n\\n${result.message}`;\n    \n    return {\n      content: [{\n        type: \"text\",\n        text\n      }]\n    };\n  }\n}"]}

package/dist/index.d.ts

@@ -416,6 +416,24 @@ export declare class DollhouseMCPServer implements IToolHandler {
             text: string;
         }[];
     }>;
+    /**
+     * Handle configuration operations - delegates to ConfigHandler
+     */
+    handleConfigOperation(options: any): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    /**
+     * Handle sync operations - delegates to SyncHandler
+     */
+    handleSyncOperation(options: any): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
     /**
      * Search local portfolio using the metadata index system
      * This provides fast, comprehensive search across all element types