@dollhousemcp/mcp-server 1.7.3 → 1.7.4

package/dist/config/ConfigWizard.d.ts

@@ -0,0 +1,78 @@
+/**
+ * ConfigWizard - Interactive configuration wizard for new DollhouseMCP installations
+ *
+ * Features:
+ * - Guided walkthrough of all configuration options
+ * - Educational explanations for each setting
+ * - Tracking of completion/dismissal status
+ * - Non-intrusive first-run experience
+ * - Re-runnable via MCP tool
+ */
+import { ConfigManager } from './ConfigManager.js';
+export declare class ConfigWizard {
+    private configManager;
+    private rl;
+    private isInteractive;
+    constructor(configManager: ConfigManager);
+    /**
+     * Check if the wizard should run
+     */
+    shouldRunWizard(): Promise<boolean>;
+    /**
+     * Show initial prompt to user
+     */
+    promptInitial(): Promise<'yes' | 'skip' | 'never'>;
+    /**
+     * Run the full configuration wizard
+     */
+    runWizard(): Promise<void>;
+    /**
+     * User Identity Section
+     */
+    private runUserIdentitySection;
+    /**
+     * GitHub Integration Section
+     */
+    private runGitHubSection;
+    /**
+     * Sync Settings Section
+     */
+    private runSyncSection;
+    /**
+     * Collection Settings Section
+     */
+    private runCollectionSection;
+    /**
+     * Display Settings Section
+     */
+    private runDisplaySection;
+    /**
+     * Show configuration summary
+     */
+    private showSummary;
+    /**
+     * Mark wizard as completed
+     */
+    markCompleted(skippedSections?: string[]): Promise<void>;
+    /**
+     * Mark wizard as dismissed
+     */
+    markDismissed(): Promise<void>;
+    /**
+     * Helper: Prompt for user input
+     */
+    private prompt;
+    /**
+     * Helper: Prompt for yes/no
+     */
+    private promptYesNo;
+    /**
+     * Helper: Validate email format
+     */
+    private isValidEmail;
+    /**
+     * Cleanup readline interface
+     */
+    close(): void;
+}
+//# sourceMappingURL=ConfigWizard.d.ts.map

package/dist/config/ConfigWizard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigWizard.d.ts","sourceRoot":"","sources":["../../src/config/ConfigWizard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAanD,qBAAa,YAAY;IACvB,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,EAAE,CAA4B;IACtC,OAAO,CAAC,aAAa,CAAU;gBAEnB,aAAa,EAAE,aAAa;IAmBxC;;OAEG;IACG,eAAe,IAAI,OAAO,CAAC,OAAO,CAAC;IAUzC;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;IAwBxD;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAoEhC;;OAEG;YACW,sBAAsB;IA2CpC;;OAEG;YACW,gBAAgB;IAkC9B;;OAEG;YACW,cAAc;IA4C5B;;OAEG;YACW,oBAAoB;IAgBlC;;OAEG;YACW,iBAAiB;IAgC/B;;OAEG;YACW,WAAW;IAiCzB;;OAEG;IACG,aAAa,CAAC,eAAe,GAAE,MAAM,EAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IASlE;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAIpC;;OAEG;IACH,OAAO,CAAC,MAAM;IAad;;OAEG;YACW,WAAW;IAMzB;;OAEG;IACH,OAAO,CAAC,YAAY;IAMpB;;OAEG;IACH,KAAK,IAAI,IAAI;CAKd"}

package/dist/config/ConfigWizard.js

@@ -0,0 +1,370 @@
+/**
+ * ConfigWizard - Interactive configuration wizard for new DollhouseMCP installations
+ *
+ * Features:
+ * - Guided walkthrough of all configuration options
+ * - Educational explanations for each setting
+ * - Tracking of completion/dismissal status
+ * - Non-intrusive first-run experience
+ * - Re-runnable via MCP tool
+ */
+import * as readline from 'readline';
+import { logger } from '../utils/logger.js';
+import chalk from 'chalk';
+import { getPortfolioRepositoryName } from './portfolioConfig.js';
+const WIZARD_VERSION = '1.0.0';
+export class ConfigWizard {
+    configManager;
+    rl;
+    isInteractive;
+    constructor(configManager) {
+        this.configManager = configManager;
+        // Check if we're in an interactive terminal
+        this.isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+        // Only create readline interface if interactive
+        if (this.isInteractive) {
+            this.rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+                terminal: true
+            });
+        }
+        else {
+            // No interface in non-interactive mode
+            this.rl = null;
+        }
+    }
+    /**
+     * Check if the wizard should run
+     */
+    async shouldRunWizard() {
+        // Don't run in non-interactive environments (CI, automated scripts)
+        if (!this.isInteractive) {
+            return false;
+        }
+        const config = this.configManager.getConfig();
+        return !config.wizard?.completed && !config.wizard?.dismissed;
+    }
+    /**
+     * Show initial prompt to user
+     */
+    async promptInitial() {
+        console.log('\n' + chalk.cyan('═'.repeat(60)));
+        console.log(chalk.cyan.bold('  Welcome to DollhouseMCP! 🎭'));
+        console.log(chalk.cyan('═'.repeat(60)) + '\n');
+        console.log(chalk.yellow('This appears to be your first time using DollhouseMCP.'));
+        console.log('Would you like a guided walkthrough of the configuration options?\n');
+        console.log(chalk.green('  [1]') + ' Yes, guide me through the configuration');
+        console.log(chalk.yellow('  [2]') + ' Skip for now (ask again next time)');
+        console.log(chalk.gray('  [3]') + ' Don\'t show this again\n');
+        const choice = await this.prompt('Choice [1/2/3]: ', '2');
+        switch (choice) {
+            case '1':
+                return 'yes';
+            case '3':
+                return 'never';
+            default:
+                return 'skip';
+        }
+    }
+    /**
+     * Run the full configuration wizard
+     */
+    async runWizard() {
+        console.log('\n' + chalk.cyan('Starting Configuration Wizard...'));
+        console.log(chalk.gray('You can press Ctrl+C at any time to exit\n'));
+        try {
+            // Track skipped sections
+            const skippedSections = [];
+            // Section 1: User Identity
+            const skipIdentity = await this.runUserIdentitySection();
+            if (skipIdentity)
+                skippedSections.push('user');
+            // Section 2: GitHub Integration
+            const skipGitHub = await this.runGitHubSection();
+            if (skipGitHub)
+                skippedSections.push('github');
+            // Section 3: Sync Settings
+            const skipSync = await this.runSyncSection();
+            if (skipSync)
+                skippedSections.push('sync');
+            // Section 4: Collection Settings
+            const skipCollection = await this.runCollectionSection();
+            if (skipCollection)
+                skippedSections.push('collection');
+            // Section 5: Display Settings
+            const skipDisplay = await this.runDisplaySection();
+            if (skipDisplay)
+                skippedSections.push('display');
+            // Show summary and confirm
+            await this.showSummary();
+            const save = await this.promptYesNo('Save this configuration?', true);
+            if (save) {
+                await this.markCompleted(skippedSections);
+                console.log(chalk.green('\n✅ Configuration saved successfully!'));
+                console.log(chalk.gray('You can re-run this wizard anytime with the "run_config_wizard" tool.\n'));
+            }
+            else {
+                console.log(chalk.yellow('\n⚠️  Configuration not saved. You can run the wizard again later.\n'));
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.message.includes('canceled')) {
+                    console.log(chalk.yellow('\n⚠️  Wizard canceled. You can run it again later.\n'));
+                }
+                else if (error.message.includes('EACCES') || error.message.includes('permission')) {
+                    logger.error('Permission denied while saving configuration', { error });
+                    console.log(chalk.red('\n❌ Permission denied: Unable to save configuration.'));
+                    console.log(chalk.yellow('   Please check file permissions for ~/.dollhouse/config.yml\n'));
+                }
+                else if (error.message.includes('ENOSPC')) {
+                    logger.error('No space left on device', { error });
+                    console.log(chalk.red('\n❌ Disk full: Unable to save configuration.'));
+                    console.log(chalk.yellow('   Please free up some disk space and try again.\n'));
+                }
+                else if (error.message.includes('readline')) {
+                    logger.error('Terminal input error', { error });
+                    console.log(chalk.red('\n❌ Terminal error: Unable to read input.'));
+                    console.log(chalk.yellow('   Please ensure you\'re running in an interactive terminal.\n'));
+                }
+                else {
+                    logger.error('Unexpected error in configuration wizard', { error });
+                    console.log(chalk.red('\n❌ An unexpected error occurred.'));
+                    console.log(chalk.gray(`   Error: ${error.message}\n`));
+                }
+            }
+            else {
+                logger.error('Unknown error in configuration wizard', { error });
+                console.log(chalk.red('\n❌ An unknown error occurred. Please try again later.\n'));
+            }
+        }
+    }
+    /**
+     * User Identity Section
+     */
+    async runUserIdentitySection() {
+        console.log('\n' + chalk.cyan.bold('=== User Identity Configuration ==='));
+        console.log('Let\'s set up your identity for persona attribution.\n');
+        const config = this.configManager.getConfig();
+        // Username
+        console.log(chalk.white('Username (for persona credits):'));
+        console.log(chalk.gray(`  Current: ${config.user.username || 'not set'}`));
+        console.log(chalk.gray('  Recommended: Your GitHub username'));
+        const username = await this.prompt('  > ', config.user.username || '');
+        if (username) {
+            await this.configManager.updateSetting('user.username', username);
+        }
+        // Email with validation
+        console.log(chalk.white('\nEmail (for Git commits and GitHub attribution):'));
+        console.log(chalk.gray('  Used for: Git author info, GitHub commits, and element attribution'));
+        console.log(chalk.gray(`  Current: ${config.user.email || 'not set'}`));
+        console.log(chalk.gray('  Recommended: Your GitHub email address'));
+        let email = await this.prompt('  > ', config.user.email || '');
+        // Validate email if provided
+        while (email && !this.isValidEmail(email)) {
+            console.log(chalk.yellow('  ⚠️  Invalid email format. Please enter a valid email or leave empty to skip.'));
+            email = await this.prompt('  > ', '');
+        }
+        if (email) {
+            await this.configManager.updateSetting('user.email', email);
+        }
+        // Display Name
+        console.log(chalk.white('\nDisplay Name (how you appear in the community):'));
+        console.log(chalk.gray(`  Current: ${config.user.display_name || 'not set'}`));
+        const displayName = await this.prompt('  > ', config.user.display_name || '');
+        if (displayName) {
+            await this.configManager.updateSetting('user.display_name', displayName);
+        }
+        return false; // Section not skipped
+    }
+    /**
+     * GitHub Integration Section
+     */
+    async runGitHubSection() {
+        console.log('\n' + chalk.cyan.bold('=== GitHub Integration ==='));
+        console.log('DollhouseMCP can sync your personas with GitHub for backup and sharing.\n');
+        const setupGitHub = await this.promptYesNo('Would you like to set up GitHub integration?', false);
+        if (!setupGitHub) {
+            console.log(chalk.gray('  Skipping GitHub setup. You can configure this later.\n'));
+            return true; // Section skipped
+        }
+        const config = this.configManager.getConfig();
+        // Repository name
+        console.log(chalk.white('\nGitHub Portfolio Repository:'));
+        console.log(chalk.gray('  This will store your personal collection'));
+        console.log(chalk.gray('  Format: username/repository-name'));
+        console.log(chalk.gray(`  Default: ${config.github.portfolio.repository_name}`));
+        const repoName = await this.prompt('  > ', config.github.portfolio.repository_name);
+        if (repoName) {
+            await this.configManager.updateSetting('github.portfolio.repository_name', repoName);
+        }
+        // Auto-create repository
+        const autoCreate = await this.promptYesNo('\nAuto-create repository if it doesn\'t exist?', true);
+        await this.configManager.updateSetting('github.portfolio.auto_create', autoCreate);
+        // OAuth authentication
+        const useOAuth = await this.promptYesNo('\nUse OAuth for authentication? (More secure than tokens)', true);
+        await this.configManager.updateSetting('github.auth.use_oauth', useOAuth);
+        return false; // Section not skipped
+    }
+    /**
+     * Sync Settings Section
+     */
+    async runSyncSection() {
+        console.log('\n' + chalk.cyan.bold('=== Sync Settings ==='));
+        console.log('Control how your personas sync with GitHub.\n');
+        const enableSync = await this.promptYesNo('Enable sync features? (You can always enable later)', false);
+        await this.configManager.updateSetting('sync.enabled', enableSync);
+        if (!enableSync) {
+            console.log(chalk.gray('  Sync disabled. You can enable it later in settings.\n'));
+            return true; // Section skipped (partially)
+        }
+        // Individual sync settings
+        console.log(chalk.white('\nIndividual Sync Settings:'));
+        const requireConfirm = await this.promptYesNo('  Require confirmation before sync?', true);
+        await this.configManager.updateSetting('sync.individual.require_confirmation', requireConfirm);
+        const showDiff = await this.promptYesNo('  Show diff before syncing?', true);
+        await this.configManager.updateSetting('sync.individual.show_diff_before_sync', showDiff);
+        const trackVersions = await this.promptYesNo('  Keep version history?', true);
+        await this.configManager.updateSetting('sync.individual.track_versions', trackVersions);
+        if (trackVersions) {
+            const historyCount = await this.prompt('    How many versions to keep? [10]: ', '10');
+            await this.configManager.updateSetting('sync.individual.keep_history', parseInt(historyCount) || 10);
+        }
+        // Privacy settings
+        console.log(chalk.white('\nPrivacy Settings:'));
+        const scanSecrets = await this.promptYesNo('  Scan for secrets before upload?', true);
+        await this.configManager.updateSetting('sync.privacy.scan_for_secrets', scanSecrets);
+        const scanPII = await this.promptYesNo('  Scan for PII (personal info)?', true);
+        await this.configManager.updateSetting('sync.privacy.scan_for_pii', scanPII);
+        const warnSensitive = await this.promptYesNo('  Warn on sensitive content?', true);
+        await this.configManager.updateSetting('sync.privacy.warn_on_sensitive', warnSensitive);
+        return false; // Section not skipped
+    }
+    /**
+     * Collection Settings Section
+     */
+    async runCollectionSection() {
+        console.log('\n' + chalk.cyan.bold('=== Collection Settings ==='));
+        console.log('The DollhouseMCP Collection is our community marketplace.\n');
+        const autoSubmit = await this.promptYesNo('Auto-submit to collection when uploading?', false);
+        await this.configManager.updateSetting('collection.auto_submit', autoSubmit);
+        const requireReview = await this.promptYesNo('Require review before submission?', true);
+        await this.configManager.updateSetting('collection.require_review', requireReview);
+        const addAttribution = await this.promptYesNo('Add attribution to your personas? (Adds your username)', true);
+        await this.configManager.updateSetting('collection.add_attribution', addAttribution);
+        return false; // Section not skipped
+    }
+    /**
+     * Display Settings Section
+     */
+    async runDisplaySection() {
+        console.log('\n' + chalk.cyan.bold('=== Display Settings ==='));
+        console.log('How DollhouseMCP appears in your terminal.\n');
+        const showIndicators = await this.promptYesNo('Show persona indicators in responses?', true);
+        await this.configManager.updateSetting('display.persona_indicators.enabled', showIndicators);
+        if (showIndicators) {
+            console.log(chalk.white('\nIndicator Style:'));
+            console.log('  [1] Full - Complete information');
+            console.log('  [2] Minimal - Just the name');
+            console.log('  [3] Compact - Name and version');
+            console.log('  [4] Custom - Define your own format');
+            const styleChoice = await this.prompt('  Choice [1-4]: ', '2');
+            const styles = ['full', 'minimal', 'compact', 'custom'];
+            const style = styles[parseInt(styleChoice) - 1] || 'minimal';
+            await this.configManager.updateSetting('display.persona_indicators.style', style);
+            const includeEmoji = await this.promptYesNo('\n  Include emoji in indicators?', true);
+            await this.configManager.updateSetting('display.persona_indicators.include_emoji', includeEmoji);
+        }
+        const verboseLogging = await this.promptYesNo('\nEnable verbose logging?', false);
+        await this.configManager.updateSetting('display.verbose_logging', verboseLogging);
+        const showProgress = await this.promptYesNo('Show progress indicators?', true);
+        await this.configManager.updateSetting('display.show_progress', showProgress);
+        return false; // Section not skipped
+    }
+    /**
+     * Show configuration summary
+     */
+    async showSummary() {
+        console.log('\n' + chalk.cyan.bold('=== Configuration Summary ==='));
+        console.log('Here\'s what we\'ll set up:\n');
+        const config = this.configManager.getConfig();
+        // User
+        if (config.user.username) {
+            console.log(chalk.green('✓') + ` Username: ${config.user.username}`);
+        }
+        if (config.user.email) {
+            console.log(chalk.green('✓') + ` Email: ${config.user.email}`);
+        }
+        // GitHub
+        const defaultRepoName = getPortfolioRepositoryName();
+        if (config.github.portfolio.repository_name !== defaultRepoName) {
+            console.log(chalk.green('✓') + ` GitHub: ${config.github.portfolio.repository_name}`);
+        }
+        // Sync
+        console.log(chalk.green('✓') + ` Sync: ${config.sync.enabled ? 'Enabled' : 'Disabled'}`);
+        // Collection
+        console.log(chalk.green('✓') + ` Collection: ${config.collection.auto_submit ? 'Auto-submit' : 'Manual submission'}`);
+        // Display
+        if (config.display.persona_indicators.enabled) {
+            console.log(chalk.green('✓') + ` Display: ${config.display.persona_indicators.style} indicators` +
+                (config.display.persona_indicators.include_emoji ? ' with emoji' : ''));
+        }
+    }
+    /**
+     * Mark wizard as completed
+     */
+    async markCompleted(skippedSections = []) {
+        await this.configManager.updateSetting('wizard.completed', true);
+        await this.configManager.updateSetting('wizard.completedAt', new Date().toISOString());
+        await this.configManager.updateSetting('wizard.version', WIZARD_VERSION);
+        if (skippedSections.length > 0) {
+            await this.configManager.updateSetting('wizard.skippedSections', skippedSections);
+        }
+    }
+    /**
+     * Mark wizard as dismissed
+     */
+    async markDismissed() {
+        await this.configManager.updateSetting('wizard.dismissed', true);
+    }
+    /**
+     * Helper: Prompt for user input
+     */
+    prompt(question, defaultValue = '') {
+        return new Promise((resolve) => {
+            if (!this.isInteractive || !this.rl) {
+                resolve(defaultValue);
+                return;
+            }
+            this.rl.question(question, (answer) => {
+                resolve(answer || defaultValue);
+            });
+        });
+    }
+    /**
+     * Helper: Prompt for yes/no
+     */
+    async promptYesNo(question, defaultYes = true) {
+        const hint = defaultYes ? '[Y/n]' : '[y/N]';
+        const answer = await this.prompt(`${question} ${hint}: `, defaultYes ? 'y' : 'n');
+        return answer.toLowerCase().startsWith('y');
+    }
+    /**
+     * Helper: Validate email format
+     */
+    isValidEmail(email) {
+        // Basic email regex - not perfect but good enough for wizard validation
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(email);
+    }
+    /**
+     * Cleanup readline interface
+     */
+    close() {
+        if (this.isInteractive && this.rl) {
+            this.rl.close();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ConfigWizard.js","sourceRoot":"","sources":["../../src/config/ConfigWizard.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ConfigWizard - Interactive configuration wizard for new DollhouseMCP installations\n * \n * Features:\n * - Guided walkthrough of all configuration options\n * - Educational explanations for each setting\n * - Tracking of completion/dismissal status\n * - Non-intrusive first-run experience\n * - Re-runnable via MCP tool\n */\n\nimport * as readline from 'readline';\nimport { ConfigManager } from './ConfigManager.js';\nimport { logger } from '../utils/logger.js';\nimport chalk from 'chalk';\nimport { getPortfolioRepositoryName } from './portfolioConfig.js';\n\nconst WIZARD_VERSION = '1.0.0';\n\ninterface WizardChoice {\n  value: string;\n  label: string;\n  isDefault?: boolean;\n}\n\nexport class ConfigWizard {\n  private configManager: ConfigManager;\n  private rl: readline.Interface | null;\n  private isInteractive: boolean;\n\n  constructor(configManager: ConfigManager) {\n    this.configManager = configManager;\n    \n    // Check if we're in an interactive terminal\n    this.isInteractive = process.stdin.isTTY && process.stdout.isTTY;\n    \n    // Only create readline interface if interactive\n    if (this.isInteractive) {\n      this.rl = readline.createInterface({\n        input: process.stdin,\n        output: process.stdout,\n        terminal: true\n      });\n    } else {\n      // No interface in non-interactive mode\n      this.rl = null;\n    }\n  }\n\n  /**\n   * Check if the wizard should run\n   */\n  async shouldRunWizard(): Promise<boolean> {\n    // Don't run in non-interactive environments (CI, automated scripts)\n    if (!this.isInteractive) {\n      return false;\n    }\n\n    const config = this.configManager.getConfig();\n    return !config.wizard?.completed && !config.wizard?.dismissed;\n  }\n\n  /**\n   * Show initial prompt to user\n   */\n  async promptInitial(): Promise<'yes' | 'skip' | 'never'> {\n    console.log('\\n' + chalk.cyan('═'.repeat(60)));\n    console.log(chalk.cyan.bold('  Welcome to DollhouseMCP! 🎭'));\n    console.log(chalk.cyan('═'.repeat(60)) + '\\n');\n    \n    console.log(chalk.yellow('This appears to be your first time using DollhouseMCP.'));\n    console.log('Would you like a guided walkthrough of the configuration options?\\n');\n    \n    console.log(chalk.green('  [1]') + ' Yes, guide me through the configuration');\n    console.log(chalk.yellow('  [2]') + ' Skip for now (ask again next time)');\n    console.log(chalk.gray('  [3]') + ' Don\\'t show this again\\n');\n\n    const choice = await this.prompt('Choice [1/2/3]: ', '2');\n    \n    switch (choice) {\n      case '1':\n        return 'yes';\n      case '3':\n        return 'never';\n      default:\n        return 'skip';\n    }\n  }\n\n  /**\n   * Run the full configuration wizard\n   */\n  async runWizard(): Promise<void> {\n    console.log('\\n' + chalk.cyan('Starting Configuration Wizard...'));\n    console.log(chalk.gray('You can press Ctrl+C at any time to exit\\n'));\n\n    try {\n      // Track skipped sections\n      const skippedSections: string[] = [];\n\n      // Section 1: User Identity\n      const skipIdentity = await this.runUserIdentitySection();\n      if (skipIdentity) skippedSections.push('user');\n\n      // Section 2: GitHub Integration\n      const skipGitHub = await this.runGitHubSection();\n      if (skipGitHub) skippedSections.push('github');\n\n      // Section 3: Sync Settings\n      const skipSync = await this.runSyncSection();\n      if (skipSync) skippedSections.push('sync');\n\n      // Section 4: Collection Settings\n      const skipCollection = await this.runCollectionSection();\n      if (skipCollection) skippedSections.push('collection');\n\n      // Section 5: Display Settings\n      const skipDisplay = await this.runDisplaySection();\n      if (skipDisplay) skippedSections.push('display');\n\n      // Show summary and confirm\n      await this.showSummary();\n      \n      const save = await this.promptYesNo('Save this configuration?', true);\n      if (save) {\n        await this.markCompleted(skippedSections);\n        console.log(chalk.green('\\n✅ Configuration saved successfully!'));\n        console.log(chalk.gray('You can re-run this wizard anytime with the \"run_config_wizard\" tool.\\n'));\n      } else {\n        console.log(chalk.yellow('\\n⚠️  Configuration not saved. You can run the wizard again later.\\n'));\n      }\n\n    } catch (error) {\n      if (error instanceof Error) {\n        if (error.message.includes('canceled')) {\n          console.log(chalk.yellow('\\n⚠️  Wizard canceled. You can run it again later.\\n'));\n        } else if (error.message.includes('EACCES') || error.message.includes('permission')) {\n          logger.error('Permission denied while saving configuration', { error });\n          console.log(chalk.red('\\n❌ Permission denied: Unable to save configuration.'));\n          console.log(chalk.yellow('   Please check file permissions for ~/.dollhouse/config.yml\\n'));\n        } else if (error.message.includes('ENOSPC')) {\n          logger.error('No space left on device', { error });\n          console.log(chalk.red('\\n❌ Disk full: Unable to save configuration.'));\n          console.log(chalk.yellow('   Please free up some disk space and try again.\\n'));\n        } else if (error.message.includes('readline')) {\n          logger.error('Terminal input error', { error });\n          console.log(chalk.red('\\n❌ Terminal error: Unable to read input.'));\n          console.log(chalk.yellow('   Please ensure you\\'re running in an interactive terminal.\\n'));\n        } else {\n          logger.error('Unexpected error in configuration wizard', { error });\n          console.log(chalk.red('\\n❌ An unexpected error occurred.'));\n          console.log(chalk.gray(`   Error: ${error.message}\\n`));\n        }\n      } else {\n        logger.error('Unknown error in configuration wizard', { error });\n        console.log(chalk.red('\\n❌ An unknown error occurred. Please try again later.\\n'));\n      }\n    }\n  }\n\n  /**\n   * User Identity Section\n   */\n  private async runUserIdentitySection(): Promise<boolean> {\n    console.log('\\n' + chalk.cyan.bold('=== User Identity Configuration ==='));\n    console.log('Let\\'s set up your identity for persona attribution.\\n');\n\n    const config = this.configManager.getConfig();\n    \n    // Username\n    console.log(chalk.white('Username (for persona credits):'));\n    console.log(chalk.gray(`  Current: ${config.user.username || 'not set'}`));\n    console.log(chalk.gray('  Recommended: Your GitHub username'));\n    const username = await this.prompt('  > ', config.user.username || '');\n    if (username) {\n      await this.configManager.updateSetting('user.username', username);\n    }\n\n    // Email with validation\n    console.log(chalk.white('\\nEmail (for Git commits and GitHub attribution):'));\n    console.log(chalk.gray('  Used for: Git author info, GitHub commits, and element attribution'));\n    console.log(chalk.gray(`  Current: ${config.user.email || 'not set'}`));\n    console.log(chalk.gray('  Recommended: Your GitHub email address'));\n    let email = await this.prompt('  > ', config.user.email || '');\n    \n    // Validate email if provided\n    while (email && !this.isValidEmail(email)) {\n      console.log(chalk.yellow('  ⚠️  Invalid email format. Please enter a valid email or leave empty to skip.'));\n      email = await this.prompt('  > ', '');\n    }\n    \n    if (email) {\n      await this.configManager.updateSetting('user.email', email);\n    }\n\n    // Display Name\n    console.log(chalk.white('\\nDisplay Name (how you appear in the community):'));\n    console.log(chalk.gray(`  Current: ${config.user.display_name || 'not set'}`));\n    const displayName = await this.prompt('  > ', config.user.display_name || '');\n    if (displayName) {\n      await this.configManager.updateSetting('user.display_name', displayName);\n    }\n\n    return false; // Section not skipped\n  }\n\n  /**\n   * GitHub Integration Section\n   */\n  private async runGitHubSection(): Promise<boolean> {\n    console.log('\\n' + chalk.cyan.bold('=== GitHub Integration ==='));\n    console.log('DollhouseMCP can sync your personas with GitHub for backup and sharing.\\n');\n\n    const setupGitHub = await this.promptYesNo('Would you like to set up GitHub integration?', false);\n    \n    if (!setupGitHub) {\n      console.log(chalk.gray('  Skipping GitHub setup. You can configure this later.\\n'));\n      return true; // Section skipped\n    }\n\n    const config = this.configManager.getConfig();\n\n    // Repository name\n    console.log(chalk.white('\\nGitHub Portfolio Repository:'));\n    console.log(chalk.gray('  This will store your personal collection'));\n    console.log(chalk.gray('  Format: username/repository-name'));\n    console.log(chalk.gray(`  Default: ${config.github.portfolio.repository_name}`));\n    const repoName = await this.prompt('  > ', config.github.portfolio.repository_name);\n    if (repoName) {\n      await this.configManager.updateSetting('github.portfolio.repository_name', repoName);\n    }\n\n    // Auto-create repository\n    const autoCreate = await this.promptYesNo('\\nAuto-create repository if it doesn\\'t exist?', true);\n    await this.configManager.updateSetting('github.portfolio.auto_create', autoCreate);\n\n    // OAuth authentication\n    const useOAuth = await this.promptYesNo('\\nUse OAuth for authentication? (More secure than tokens)', true);\n    await this.configManager.updateSetting('github.auth.use_oauth', useOAuth);\n\n    return false; // Section not skipped\n  }\n\n  /**\n   * Sync Settings Section\n   */\n  private async runSyncSection(): Promise<boolean> {\n    console.log('\\n' + chalk.cyan.bold('=== Sync Settings ==='));\n    console.log('Control how your personas sync with GitHub.\\n');\n\n    const enableSync = await this.promptYesNo('Enable sync features? (You can always enable later)', false);\n    await this.configManager.updateSetting('sync.enabled', enableSync);\n\n    if (!enableSync) {\n      console.log(chalk.gray('  Sync disabled. You can enable it later in settings.\\n'));\n      return true; // Section skipped (partially)\n    }\n\n    // Individual sync settings\n    console.log(chalk.white('\\nIndividual Sync Settings:'));\n    \n    const requireConfirm = await this.promptYesNo('  Require confirmation before sync?', true);\n    await this.configManager.updateSetting('sync.individual.require_confirmation', requireConfirm);\n\n    const showDiff = await this.promptYesNo('  Show diff before syncing?', true);\n    await this.configManager.updateSetting('sync.individual.show_diff_before_sync', showDiff);\n\n    const trackVersions = await this.promptYesNo('  Keep version history?', true);\n    await this.configManager.updateSetting('sync.individual.track_versions', trackVersions);\n\n    if (trackVersions) {\n      const historyCount = await this.prompt('    How many versions to keep? [10]: ', '10');\n      await this.configManager.updateSetting('sync.individual.keep_history', parseInt(historyCount) || 10);\n    }\n\n    // Privacy settings\n    console.log(chalk.white('\\nPrivacy Settings:'));\n    \n    const scanSecrets = await this.promptYesNo('  Scan for secrets before upload?', true);\n    await this.configManager.updateSetting('sync.privacy.scan_for_secrets', scanSecrets);\n\n    const scanPII = await this.promptYesNo('  Scan for PII (personal info)?', true);\n    await this.configManager.updateSetting('sync.privacy.scan_for_pii', scanPII);\n\n    const warnSensitive = await this.promptYesNo('  Warn on sensitive content?', true);\n    await this.configManager.updateSetting('sync.privacy.warn_on_sensitive', warnSensitive);\n\n    return false; // Section not skipped\n  }\n\n  /**\n   * Collection Settings Section\n   */\n  private async runCollectionSection(): Promise<boolean> {\n    console.log('\\n' + chalk.cyan.bold('=== Collection Settings ==='));\n    console.log('The DollhouseMCP Collection is our community marketplace.\\n');\n\n    const autoSubmit = await this.promptYesNo('Auto-submit to collection when uploading?', false);\n    await this.configManager.updateSetting('collection.auto_submit', autoSubmit);\n\n    const requireReview = await this.promptYesNo('Require review before submission?', true);\n    await this.configManager.updateSetting('collection.require_review', requireReview);\n\n    const addAttribution = await this.promptYesNo('Add attribution to your personas? (Adds your username)', true);\n    await this.configManager.updateSetting('collection.add_attribution', addAttribution);\n\n    return false; // Section not skipped\n  }\n\n  /**\n   * Display Settings Section\n   */\n  private async runDisplaySection(): Promise<boolean> {\n    console.log('\\n' + chalk.cyan.bold('=== Display Settings ==='));\n    console.log('How DollhouseMCP appears in your terminal.\\n');\n\n    const showIndicators = await this.promptYesNo('Show persona indicators in responses?', true);\n    await this.configManager.updateSetting('display.persona_indicators.enabled', showIndicators);\n\n    if (showIndicators) {\n      console.log(chalk.white('\\nIndicator Style:'));\n      console.log('  [1] Full - Complete information');\n      console.log('  [2] Minimal - Just the name');\n      console.log('  [3] Compact - Name and version');\n      console.log('  [4] Custom - Define your own format');\n      \n      const styleChoice = await this.prompt('  Choice [1-4]: ', '2');\n      const styles = ['full', 'minimal', 'compact', 'custom'];\n      const style = styles[parseInt(styleChoice) - 1] || 'minimal';\n      await this.configManager.updateSetting('display.persona_indicators.style', style);\n\n      const includeEmoji = await this.promptYesNo('\\n  Include emoji in indicators?', true);\n      await this.configManager.updateSetting('display.persona_indicators.include_emoji', includeEmoji);\n    }\n\n    const verboseLogging = await this.promptYesNo('\\nEnable verbose logging?', false);\n    await this.configManager.updateSetting('display.verbose_logging', verboseLogging);\n\n    const showProgress = await this.promptYesNo('Show progress indicators?', true);\n    await this.configManager.updateSetting('display.show_progress', showProgress);\n\n    return false; // Section not skipped\n  }\n\n  /**\n   * Show configuration summary\n   */\n  private async showSummary(): Promise<void> {\n    console.log('\\n' + chalk.cyan.bold('=== Configuration Summary ==='));\n    console.log('Here\\'s what we\\'ll set up:\\n');\n\n    const config = this.configManager.getConfig();\n\n    // User\n    if (config.user.username) {\n      console.log(chalk.green('✓') + ` Username: ${config.user.username}`);\n    }\n    if (config.user.email) {\n      console.log(chalk.green('✓') + ` Email: ${config.user.email}`);\n    }\n\n    // GitHub\n    const defaultRepoName = getPortfolioRepositoryName();\n    if (config.github.portfolio.repository_name !== defaultRepoName) {\n      console.log(chalk.green('✓') + ` GitHub: ${config.github.portfolio.repository_name}`);\n    }\n\n    // Sync\n    console.log(chalk.green('✓') + ` Sync: ${config.sync.enabled ? 'Enabled' : 'Disabled'}`);\n\n    // Collection\n    console.log(chalk.green('✓') + ` Collection: ${config.collection.auto_submit ? 'Auto-submit' : 'Manual submission'}`);\n\n    // Display\n    if (config.display.persona_indicators.enabled) {\n      console.log(chalk.green('✓') + ` Display: ${config.display.persona_indicators.style} indicators` +\n        (config.display.persona_indicators.include_emoji ? ' with emoji' : ''));\n    }\n  }\n\n  /**\n   * Mark wizard as completed\n   */\n  async markCompleted(skippedSections: string[] = []): Promise<void> {\n    await this.configManager.updateSetting('wizard.completed', true);\n    await this.configManager.updateSetting('wizard.completedAt', new Date().toISOString());\n    await this.configManager.updateSetting('wizard.version', WIZARD_VERSION);\n    if (skippedSections.length > 0) {\n      await this.configManager.updateSetting('wizard.skippedSections', skippedSections);\n    }\n  }\n\n  /**\n   * Mark wizard as dismissed\n   */\n  async markDismissed(): Promise<void> {\n    await this.configManager.updateSetting('wizard.dismissed', true);\n  }\n\n  /**\n   * Helper: Prompt for user input\n   */\n  private prompt(question: string, defaultValue: string = ''): Promise<string> {\n    return new Promise((resolve) => {\n      if (!this.isInteractive || !this.rl) {\n        resolve(defaultValue);\n        return;\n      }\n\n      this.rl.question(question, (answer) => {\n        resolve(answer || defaultValue);\n      });\n    });\n  }\n\n  /**\n   * Helper: Prompt for yes/no\n   */\n  private async promptYesNo(question: string, defaultYes: boolean = true): Promise<boolean> {\n    const hint = defaultYes ? '[Y/n]' : '[y/N]';\n    const answer = await this.prompt(`${question} ${hint}: `, defaultYes ? 'y' : 'n');\n    return answer.toLowerCase().startsWith('y');\n  }\n\n  /**\n   * Helper: Validate email format\n   */\n  private isValidEmail(email: string): boolean {\n    // Basic email regex - not perfect but good enough for wizard validation\n    const emailRegex = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/;\n    return emailRegex.test(email);\n  }\n\n  /**\n   * Cleanup readline interface\n   */\n  close(): void {\n    if (this.isInteractive && this.rl) {\n      this.rl.close();\n    }\n  }\n}"]}

package/dist/config/ConfigWizardCheck.d.ts

@@ -0,0 +1,47 @@
+/**
+ * ConfigWizardCheck - Handles checking if the configuration wizard should run
+ * on first interaction with the MCP server
+ */
+export declare class ConfigWizardCheck {
+    private hasCheckedWizard;
+    private configManager;
+    private currentVersion;
+    constructor();
+    /**
+     * Get the current version from package.json
+     */
+    private getCurrentVersion;
+    /**
+     * Check if configuration wizard should run on first interaction
+     * Returns a prompt message if wizard should run, null otherwise
+     */
+    checkIfWizardNeeded(): Promise<string | null>;
+    /**
+     * Determine if we should show the update wizard based on version changes
+     * This logic can be updated with each release to trigger when needed
+     */
+    private shouldShowUpdateWizard;
+    /**
+     * Get the wizard prompt message - friendly for non-technical users
+     */
+    private getWizardPrompt;
+    /**
+     * Get the update wizard prompt for returning users
+     * This can be customized for each release that needs to notify users
+     */
+    private getUpdateWizardPrompt;
+    /**
+     * Wrap tool responses to check for wizard on first interaction
+     * CRITICAL FIX: Create new response objects to avoid mutations
+     */
+    wrapResponse(response: any): Promise<any>;
+    /**
+     * Mark wizard as completed
+     */
+    markWizardCompleted(): Promise<void>;
+    /**
+     * Mark wizard as dismissed
+     */
+    markWizardDismissed(): Promise<void>;
+}
+//# sourceMappingURL=ConfigWizardCheck.d.ts.map

package/dist/config/ConfigWizardCheck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigWizardCheck.d.ts","sourceRoot":"","sources":["../../src/config/ConfigWizardCheck.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,gBAAgB,CAAkB;IAC1C,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,cAAc,CAAS;;IAO/B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAazB;;;OAGG;IACG,mBAAmB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAkCnD;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAgB9B;;OAEG;IACH,OAAO,CAAC,eAAe;IAiCvB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAoB7B;;;OAGG;IACG,YAAY,CAAC,QAAQ,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IAoD/C;;OAEG;IACG,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC;IAM1C;;OAEG;IACG,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC;CAG3C"}