@dollhousemcp/mcp-server 1.3.0

package/dist/test/src/update/UpdateManager.js

@@ -0,0 +1,260 @@
+/**
+ * Manage server updates and rollbacks
+ */
+import { safeExec } from '../utils/git.js';
+import { VersionManager } from './VersionManager.js';
+import { UpdateChecker } from './UpdateChecker.js';
+import { DependencyChecker } from './DependencyChecker.js';
+import { BackupManager } from './BackupManager.js';
+export class UpdateManager {
+    versionManager;
+    updateChecker;
+    dependencyChecker;
+    backupManager;
+    rootDir;
+    constructor(rootDir) {
+        this.rootDir = rootDir || process.cwd();
+        this.versionManager = new VersionManager();
+        this.updateChecker = new UpdateChecker(this.versionManager);
+        this.dependencyChecker = new DependencyChecker(this.versionManager);
+        this.backupManager = new BackupManager(this.rootDir);
+    }
+    /**
+     * Check for available updates
+     */
+    async checkForUpdates() {
+        try {
+            const result = await this.updateChecker.checkForUpdates();
+            const text = this.updateChecker.formatUpdateCheckResult(result);
+            return { text };
+        }
+        catch (error) {
+            const text = this.updateChecker.formatUpdateCheckResult(null, error);
+            return { text };
+        }
+    }
+    /**
+     * Perform server update
+     */
+    async updateServer(createBackup = true, personaIndicator = '') {
+        const progress = [];
+        try {
+            // Step 1: Check dependencies
+            progress.push({ step: 'dependencies', message: 'Checking system dependencies...', isComplete: false });
+            const dependencies = await this.dependencyChecker.checkDependencies();
+            if (!dependencies.git.installed || dependencies.git.error) {
+                return {
+                    text: personaIndicator + '❌ **Update Failed**\n\n' +
+                        'Git is required for updates but is not available.\n' +
+                        dependencies.git.error || 'Git is not installed.'
+                };
+            }
+            if (!dependencies.npm.installed || dependencies.npm.error) {
+                return {
+                    text: personaIndicator + '❌ **Update Failed**\n\n' +
+                        'npm is required for updates but is not available.\n' +
+                        dependencies.npm.error || 'npm is not installed.'
+                };
+            }
+            progress[0].isComplete = true;
+            // Step 2: Create backup if requested
+            if (createBackup) {
+                progress.push({ step: 'backup', message: 'Creating backup...', isComplete: false });
+                const currentVersion = await this.versionManager.getCurrentVersion();
+                const backup = await this.backupManager.createBackup(currentVersion);
+                progress[1].isComplete = true;
+                progress[1].message = `Backup created at: ${backup.timestamp}`;
+            }
+            // Step 3: Git fetch
+            progress.push({ step: 'fetch', message: 'Fetching latest changes...', isComplete: false });
+            await safeExec('git', ['fetch', 'origin'], { cwd: this.rootDir });
+            progress[progress.length - 1].isComplete = true;
+            // Step 4: Check for uncommitted changes
+            progress.push({ step: 'check', message: 'Checking for uncommitted changes...', isComplete: false });
+            const { stdout: statusOutput } = await safeExec('git', ['status', '--porcelain'], { cwd: this.rootDir });
+            if (statusOutput.trim()) {
+                return {
+                    text: personaIndicator + '❌ **Update Failed**\n\n' +
+                        'You have uncommitted changes. Please commit or stash them before updating.\n\n' +
+                        'Modified files:\n' + statusOutput
+                };
+            }
+            progress[progress.length - 1].isComplete = true;
+            // Step 5: Git pull
+            progress.push({ step: 'pull', message: 'Pulling latest changes...', isComplete: false });
+            const { stdout: pullOutput } = await safeExec('git', ['pull', 'origin', 'main'], { cwd: this.rootDir });
+            progress[progress.length - 1].isComplete = true;
+            // Check if already up to date
+            if (pullOutput.includes('Already up to date')) {
+                return {
+                    text: personaIndicator + '✅ **Already Up to Date**\n\n' +
+                        'Your DollhouseMCP installation is already at the latest version.\n\n' +
+                        'No changes were pulled from the repository.'
+                };
+            }
+            // Step 6: npm install
+            progress.push({ step: 'install', message: 'Installing dependencies...', isComplete: false });
+            await safeExec('npm', ['install'], { cwd: this.rootDir });
+            progress[progress.length - 1].isComplete = true;
+            // Step 7: Build
+            progress.push({ step: 'build', message: 'Building TypeScript...', isComplete: false });
+            await safeExec('npm', ['run', 'build'], { cwd: this.rootDir });
+            progress[progress.length - 1].isComplete = true;
+            // Step 8: Cleanup old backups
+            if (createBackup) {
+                progress.push({ step: 'cleanup', message: 'Cleaning up old backups...', isComplete: false });
+                const deletedCount = await this.backupManager.cleanupOldBackups();
+                progress[progress.length - 1].isComplete = true;
+                progress[progress.length - 1].message = `Cleaned up ${deletedCount} old backup(s)`;
+            }
+            // Format success message
+            const successParts = [
+                personaIndicator + '✅ **Update Complete!**\n\n',
+                '**Update Summary:**\n'
+            ];
+            progress.forEach(p => {
+                successParts.push(`${p.isComplete ? '✅' : '❌'} ${p.message}\n`);
+            });
+            successParts.push('\n**Next Steps:**\n', '1. The server will restart automatically\n', '2. All personas will be reloaded\n', '3. Check `get_server_status` to verify the new version\n\n', '💡 **Tip:** If you encounter issues, use `rollback_update true` to restore the previous version.');
+            return { text: successParts.join('') };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                text: personaIndicator + '❌ **Update Failed**\n\n' +
+                    'Error: ' + errorMessage + '\n\n' +
+                    '**Progress:**\n' +
+                    progress.map(p => `${p.isComplete ? '✅' : '❌'} ${p.message}`).join('\n') + '\n\n' +
+                    '**Recovery Options:**\n' +
+                    '• Try running the update again\n' +
+                    '• Check your internet connection\n' +
+                    '• Ensure you have proper permissions\n' +
+                    '• If a backup was created, use `rollback_update true` to restore'
+            };
+        }
+    }
+    /**
+     * Rollback to previous version
+     */
+    async rollbackUpdate(force = false, personaIndicator = '') {
+        try {
+            // Get latest backup
+            const latestBackup = await this.backupManager.getLatestBackup();
+            if (!latestBackup) {
+                return {
+                    text: personaIndicator + '❌ **No Backups Found**\n\n' +
+                        'There are no backups available to restore.\n\n' +
+                        'Backups are created automatically when you run `update_server true`.'
+                };
+            }
+            // Check if rollback is needed
+            if (!force) {
+                try {
+                    // Test if the server is working by checking version
+                    await this.versionManager.getCurrentVersion();
+                    return {
+                        text: personaIndicator + '⚠️ **Rollback Confirmation Required**\n\n' +
+                            'The server appears to be working normally.\n\n' +
+                            `**Latest Backup:** ${latestBackup.timestamp}\n` +
+                            `**Backup Version:** ${latestBackup.version || 'Unknown'}\n\n` +
+                            'To force rollback anyway, use: `rollback_update true`\n\n' +
+                            '⚠️ **Warning:** This will restore all files to the backup state.'
+                    };
+                }
+                catch {
+                    // Server is broken, proceed with rollback
+                }
+            }
+            // Perform rollback
+            await this.backupManager.restoreBackup(latestBackup.path);
+            // Reinstall dependencies
+            await safeExec('npm', ['install'], { cwd: this.rootDir });
+            // Rebuild
+            await safeExec('npm', ['run', 'build'], { cwd: this.rootDir });
+            return {
+                text: personaIndicator + '✅ **Rollback Complete!**\n\n' +
+                    `Restored from backup: ${latestBackup.timestamp}\n` +
+                    `Backup version: ${latestBackup.version || 'Unknown'}\n\n` +
+                    '**What was restored:**\n' +
+                    '• All source files\n' +
+                    '• Configuration files\n' +
+                    '• Dependencies reinstalled\n' +
+                    '• TypeScript rebuilt\n\n' +
+                    '**Next Steps:**\n' +
+                    '1. The server will restart automatically\n' +
+                    '2. Check `get_server_status` to verify the version\n' +
+                    '3. Test your personas to ensure everything works'
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                text: personaIndicator + '❌ **Rollback Failed**\n\n' +
+                    'Error: ' + errorMessage + '\n\n' +
+                    '**Manual Recovery:**\n' +
+                    '1. Check the backups directory: ../dollhousemcp-backups/\n' +
+                    '2. Manually restore files if needed\n' +
+                    '3. Run `npm install` and `npm run build`\n' +
+                    '4. Contact support if issues persist'
+            };
+        }
+    }
+    /**
+     * Get current server status
+     */
+    async getServerStatus(personaIndicator = '') {
+        try {
+            const currentVersion = await this.versionManager.getCurrentVersion();
+            const dependencies = await this.dependencyChecker.checkDependencies();
+            const backups = await this.backupManager.listBackups();
+            const rateLimitStatus = this.updateChecker.getRateLimitStatus();
+            // Get git status
+            let gitStatus = 'Unknown';
+            let gitBranch = 'Unknown';
+            let lastCommit = 'Unknown';
+            try {
+                const { stdout: branchOutput } = await safeExec('git', ['branch', '--show-current'], { cwd: this.rootDir });
+                gitBranch = branchOutput.trim() || 'detached';
+                const { stdout: statusOutput } = await safeExec('git', ['status', '--porcelain'], { cwd: this.rootDir });
+                gitStatus = statusOutput.trim() ? 'Modified' : 'Clean';
+                const { stdout: logOutput } = await safeExec('git', ['log', '-1', '--oneline'], { cwd: this.rootDir });
+                lastCommit = logOutput.trim();
+            }
+            catch {
+                // Git commands failed, use defaults
+            }
+            const statusParts = [
+                personaIndicator + '📊 **DollhouseMCP Server Status**\n\n',
+                '**Version Information:**\n',
+                `• Current Version: ${currentVersion}\n`,
+                `• Git Branch: ${gitBranch}\n`,
+                `• Git Status: ${gitStatus}\n`,
+                `• Last Commit: ${lastCommit}\n\n`,
+                '**Dependencies:**\n',
+                this.dependencyChecker.formatDependencyStatus(dependencies),
+                '\n\n**Backups:**\n',
+                `• Total Backups: ${backups.length}\n`
+            ];
+            if (backups.length > 0) {
+                statusParts.push(`• Latest Backup: ${backups[0].timestamp} (v${backups[0].version || 'unknown'})\n`);
+                statusParts.push(`• Oldest Backup: ${backups[backups.length - 1].timestamp}\n`);
+            }
+            statusParts.push('\n**Rate Limit Status:**\n', `• Update Checks Remaining: ${rateLimitStatus.remainingRequests}/10 per hour\n`, `• Rate Limit Resets: ${rateLimitStatus.resetTime.toLocaleTimeString()}\n`);
+            if (!rateLimitStatus.allowed && rateLimitStatus.waitTimeSeconds) {
+                statusParts.push(`• ⏳ Wait ${rateLimitStatus.waitTimeSeconds} seconds before next check\n`);
+            }
+            statusParts.push('\n**Available Commands:**\n', '• `check_for_updates` - Check for new versions\n', '• `update_server true` - Update to latest version\n', '• `rollback_update true` - Restore from backup\n');
+            return { text: statusParts.join('') };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                text: personaIndicator + '❌ **Status Check Failed**\n\n' +
+                    'Error: ' + errorMessage + '\n\n' +
+                    'The server may be in an inconsistent state.\n' +
+                    'Try running `update_server true` to fix issues.'
+            };
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"UpdateManager.js","sourceRoot":"","sources":["../../../../src/update/UpdateManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Manage server updates and rollbacks\n */\n\nimport * as path from 'path';\nimport { safeExec } from '../utils/git.js';\nimport { VersionManager } from './VersionManager.js';\nimport { UpdateChecker } from './UpdateChecker.js';\nimport { DependencyChecker } from './DependencyChecker.js';\nimport { BackupManager } from './BackupManager.js';\n\nexport interface UpdateProgress {\n  step: string;\n  message: string;\n  isComplete: boolean;\n}\n\nexport class UpdateManager {\n  private versionManager: VersionManager;\n  private updateChecker: UpdateChecker;\n  private dependencyChecker: DependencyChecker;\n  private backupManager: BackupManager;\n  private rootDir: string;\n  \n  constructor(rootDir?: string) {\n    this.rootDir = rootDir || process.cwd();\n    this.versionManager = new VersionManager();\n    this.updateChecker = new UpdateChecker(this.versionManager);\n    this.dependencyChecker = new DependencyChecker(this.versionManager);\n    this.backupManager = new BackupManager(this.rootDir);\n  }\n  \n  /**\n   * Check for available updates\n   */\n  async checkForUpdates(): Promise<{ text: string }> {\n    try {\n      const result = await this.updateChecker.checkForUpdates();\n      const text = this.updateChecker.formatUpdateCheckResult(result);\n      return { text };\n    } catch (error) {\n      const text = this.updateChecker.formatUpdateCheckResult(null, error as Error);\n      return { text };\n    }\n  }\n  \n  /**\n   * Perform server update\n   */\n  async updateServer(createBackup: boolean = true, personaIndicator: string = ''): Promise<{ text: string }> {\n    const progress: UpdateProgress[] = [];\n    \n    try {\n      // Step 1: Check dependencies\n      progress.push({ step: 'dependencies', message: 'Checking system dependencies...', isComplete: false });\n      const dependencies = await this.dependencyChecker.checkDependencies();\n      \n      if (!dependencies.git.installed || dependencies.git.error) {\n        return {\n          text: personaIndicator + '❌ **Update Failed**\\n\\n' +\n            'Git is required for updates but is not available.\\n' +\n            dependencies.git.error || 'Git is not installed.'\n        };\n      }\n      \n      if (!dependencies.npm.installed || dependencies.npm.error) {\n        return {\n          text: personaIndicator + '❌ **Update Failed**\\n\\n' +\n            'npm is required for updates but is not available.\\n' +\n            dependencies.npm.error || 'npm is not installed.'\n        };\n      }\n      \n      progress[0].isComplete = true;\n      \n      // Step 2: Create backup if requested\n      if (createBackup) {\n        progress.push({ step: 'backup', message: 'Creating backup...', isComplete: false });\n        \n        const currentVersion = await this.versionManager.getCurrentVersion();\n        const backup = await this.backupManager.createBackup(currentVersion);\n        \n        progress[1].isComplete = true;\n        progress[1].message = `Backup created at: ${backup.timestamp}`;\n      }\n      \n      // Step 3: Git fetch\n      progress.push({ step: 'fetch', message: 'Fetching latest changes...', isComplete: false });\n      await safeExec('git', ['fetch', 'origin'], { cwd: this.rootDir });\n      progress[progress.length - 1].isComplete = true;\n      \n      // Step 4: Check for uncommitted changes\n      progress.push({ step: 'check', message: 'Checking for uncommitted changes...', isComplete: false });\n      const { stdout: statusOutput } = await safeExec('git', ['status', '--porcelain'], { cwd: this.rootDir });\n      \n      if (statusOutput.trim()) {\n        return {\n          text: personaIndicator + '❌ **Update Failed**\\n\\n' +\n            'You have uncommitted changes. Please commit or stash them before updating.\\n\\n' +\n            'Modified files:\\n' + statusOutput\n        };\n      }\n      progress[progress.length - 1].isComplete = true;\n      \n      // Step 5: Git pull\n      progress.push({ step: 'pull', message: 'Pulling latest changes...', isComplete: false });\n      const { stdout: pullOutput } = await safeExec('git', ['pull', 'origin', 'main'], { cwd: this.rootDir });\n      progress[progress.length - 1].isComplete = true;\n      \n      // Check if already up to date\n      if (pullOutput.includes('Already up to date')) {\n        return {\n          text: personaIndicator + '✅ **Already Up to Date**\\n\\n' +\n            'Your DollhouseMCP installation is already at the latest version.\\n\\n' +\n            'No changes were pulled from the repository.'\n        };\n      }\n      \n      // Step 6: npm install\n      progress.push({ step: 'install', message: 'Installing dependencies...', isComplete: false });\n      await safeExec('npm', ['install'], { cwd: this.rootDir });\n      progress[progress.length - 1].isComplete = true;\n      \n      // Step 7: Build\n      progress.push({ step: 'build', message: 'Building TypeScript...', isComplete: false });\n      await safeExec('npm', ['run', 'build'], { cwd: this.rootDir });\n      progress[progress.length - 1].isComplete = true;\n      \n      // Step 8: Cleanup old backups\n      if (createBackup) {\n        progress.push({ step: 'cleanup', message: 'Cleaning up old backups...', isComplete: false });\n        const deletedCount = await this.backupManager.cleanupOldBackups();\n        progress[progress.length - 1].isComplete = true;\n        progress[progress.length - 1].message = `Cleaned up ${deletedCount} old backup(s)`;\n      }\n      \n      // Format success message\n      const successParts = [\n        personaIndicator + '✅ **Update Complete!**\\n\\n',\n        '**Update Summary:**\\n'\n      ];\n      \n      progress.forEach(p => {\n        successParts.push(`${p.isComplete ? '✅' : '❌'} ${p.message}\\n`);\n      });\n      \n      successParts.push(\n        '\\n**Next Steps:**\\n',\n        '1. The server will restart automatically\\n',\n        '2. All personas will be reloaded\\n',\n        '3. Check `get_server_status` to verify the new version\\n\\n',\n        '💡 **Tip:** If you encounter issues, use `rollback_update true` to restore the previous version.'\n      );\n      \n      return { text: successParts.join('') };\n      \n    } catch (error) {\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      \n      return {\n        text: personaIndicator + '❌ **Update Failed**\\n\\n' +\n          'Error: ' + errorMessage + '\\n\\n' +\n          '**Progress:**\\n' + \n          progress.map(p => `${p.isComplete ? '✅' : '❌'} ${p.message}`).join('\\n') + '\\n\\n' +\n          '**Recovery Options:**\\n' +\n          '• Try running the update again\\n' +\n          '• Check your internet connection\\n' +\n          '• Ensure you have proper permissions\\n' +\n          '• If a backup was created, use `rollback_update true` to restore'\n      };\n    }\n  }\n  \n  /**\n   * Rollback to previous version\n   */\n  async rollbackUpdate(force: boolean = false, personaIndicator: string = ''): Promise<{ text: string }> {\n    try {\n      // Get latest backup\n      const latestBackup = await this.backupManager.getLatestBackup();\n      \n      if (!latestBackup) {\n        return {\n          text: personaIndicator + '❌ **No Backups Found**\\n\\n' +\n            'There are no backups available to restore.\\n\\n' +\n            'Backups are created automatically when you run `update_server true`.'\n        };\n      }\n      \n      // Check if rollback is needed\n      if (!force) {\n        try {\n          // Test if the server is working by checking version\n          await this.versionManager.getCurrentVersion();\n          \n          return {\n            text: personaIndicator + '⚠️ **Rollback Confirmation Required**\\n\\n' +\n              'The server appears to be working normally.\\n\\n' +\n              `**Latest Backup:** ${latestBackup.timestamp}\\n` +\n              `**Backup Version:** ${latestBackup.version || 'Unknown'}\\n\\n` +\n              'To force rollback anyway, use: `rollback_update true`\\n\\n' +\n              '⚠️ **Warning:** This will restore all files to the backup state.'\n          };\n        } catch {\n          // Server is broken, proceed with rollback\n        }\n      }\n      \n      // Perform rollback\n      await this.backupManager.restoreBackup(latestBackup.path);\n      \n      // Reinstall dependencies\n      await safeExec('npm', ['install'], { cwd: this.rootDir });\n      \n      // Rebuild\n      await safeExec('npm', ['run', 'build'], { cwd: this.rootDir });\n      \n      return {\n        text: personaIndicator + '✅ **Rollback Complete!**\\n\\n' +\n          `Restored from backup: ${latestBackup.timestamp}\\n` +\n          `Backup version: ${latestBackup.version || 'Unknown'}\\n\\n` +\n          '**What was restored:**\\n' +\n          '• All source files\\n' +\n          '• Configuration files\\n' +\n          '• Dependencies reinstalled\\n' +\n          '• TypeScript rebuilt\\n\\n' +\n          '**Next Steps:**\\n' +\n          '1. The server will restart automatically\\n' +\n          '2. Check `get_server_status` to verify the version\\n' +\n          '3. Test your personas to ensure everything works'\n      };\n      \n    } catch (error) {\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      \n      return {\n        text: personaIndicator + '❌ **Rollback Failed**\\n\\n' +\n          'Error: ' + errorMessage + '\\n\\n' +\n          '**Manual Recovery:**\\n' +\n          '1. Check the backups directory: ../dollhousemcp-backups/\\n' +\n          '2. Manually restore files if needed\\n' +\n          '3. Run `npm install` and `npm run build`\\n' +\n          '4. Contact support if issues persist'\n      };\n    }\n  }\n  \n  /**\n   * Get current server status\n   */\n  async getServerStatus(personaIndicator: string = ''): Promise<{ text: string }> {\n    try {\n      const currentVersion = await this.versionManager.getCurrentVersion();\n      const dependencies = await this.dependencyChecker.checkDependencies();\n      const backups = await this.backupManager.listBackups();\n      const rateLimitStatus = this.updateChecker.getRateLimitStatus();\n      \n      // Get git status\n      let gitStatus = 'Unknown';\n      let gitBranch = 'Unknown';\n      let lastCommit = 'Unknown';\n      \n      try {\n        const { stdout: branchOutput } = await safeExec('git', ['branch', '--show-current'], { cwd: this.rootDir });\n        gitBranch = branchOutput.trim() || 'detached';\n        \n        const { stdout: statusOutput } = await safeExec('git', ['status', '--porcelain'], { cwd: this.rootDir });\n        gitStatus = statusOutput.trim() ? 'Modified' : 'Clean';\n        \n        const { stdout: logOutput } = await safeExec('git', ['log', '-1', '--oneline'], { cwd: this.rootDir });\n        lastCommit = logOutput.trim();\n      } catch {\n        // Git commands failed, use defaults\n      }\n      \n      const statusParts = [\n        personaIndicator + '📊 **DollhouseMCP Server Status**\\n\\n',\n        '**Version Information:**\\n',\n        `• Current Version: ${currentVersion}\\n`,\n        `• Git Branch: ${gitBranch}\\n`,\n        `• Git Status: ${gitStatus}\\n`,\n        `• Last Commit: ${lastCommit}\\n\\n`,\n        '**Dependencies:**\\n',\n        this.dependencyChecker.formatDependencyStatus(dependencies),\n        '\\n\\n**Backups:**\\n',\n        `• Total Backups: ${backups.length}\\n`\n      ];\n      \n      if (backups.length > 0) {\n        statusParts.push(`• Latest Backup: ${backups[0].timestamp} (v${backups[0].version || 'unknown'})\\n`);\n        statusParts.push(`• Oldest Backup: ${backups[backups.length - 1].timestamp}\\n`);\n      }\n      \n      statusParts.push(\n        '\\n**Rate Limit Status:**\\n',\n        `• Update Checks Remaining: ${rateLimitStatus.remainingRequests}/10 per hour\\n`,\n        `• Rate Limit Resets: ${rateLimitStatus.resetTime.toLocaleTimeString()}\\n`\n      );\n      \n      if (!rateLimitStatus.allowed && rateLimitStatus.waitTimeSeconds) {\n        statusParts.push(`• ⏳ Wait ${rateLimitStatus.waitTimeSeconds} seconds before next check\\n`);\n      }\n      \n      statusParts.push(\n        '\\n**Available Commands:**\\n',\n        '• `check_for_updates` - Check for new versions\\n',\n        '• `update_server true` - Update to latest version\\n',\n        '• `rollback_update true` - Restore from backup\\n'\n      );\n      \n      return { text: statusParts.join('') };\n      \n    } catch (error) {\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      \n      return {\n        text: personaIndicator + '❌ **Status Check Failed**\\n\\n' +\n          'Error: ' + errorMessage + '\\n\\n' +\n          'The server may be in an inconsistent state.\\n' +\n          'Try running `update_server true` to fix issues.'\n      };\n    }\n  }\n}"]}

package/dist/test/src/update/VersionManager.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Version management and comparison utilities
+ */
+export declare class VersionManager {
+    /**
+     * Get current version from package.json
+     */
+    getCurrentVersion(): Promise<string>;
+    /**
+     * Enhanced semantic version comparison supporting pre-release versions
+     * Returns: -1 if v1 < v2, 0 if v1 == v2, 1 if v1 > v2
+     */
+    compareVersions(version1: string, version2: string): number;
+    /**
+     * Parse version from dependency output
+     */
+    parseVersionFromOutput(output: string, tool: string): string | null;
+    /**
+     * Validate that a dependency version meets requirements
+     */
+    validateDependencyVersion(actualVersion: string, requirements: {
+        minimum: string;
+        maximum: string;
+        recommended: string;
+    }, toolName: string): {
+        valid: boolean;
+        warning?: string;
+        error?: string;
+    };
+}
+//# sourceMappingURL=VersionManager.d.ts.map

package/dist/test/src/update/VersionManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VersionManager.d.ts","sourceRoot":"","sources":["../../../../src/update/VersionManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,qBAAa,cAAc;IACzB;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IAgC1C;;;OAGG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IAgC3D;;OAEG;IACH,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IA2BnE;;OAEG;IACH,yBAAyB,CACvB,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,EACvE,QAAQ,EAAE,MAAM,GACf;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;CAgCxD"}

package/dist/test/src/update/VersionManager.js

@@ -0,0 +1,134 @@
+/**
+ * Version management and comparison utilities
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export class VersionManager {
+    /**
+     * Get current version from package.json
+     */
+    async getCurrentVersion() {
+        // Use process.cwd() as a base, then search upward for package.json
+        let currentDir = process.cwd();
+        let packageJsonPath = null;
+        // Search up to 5 levels for package.json
+        for (let i = 0; i < 5; i++) {
+            const candidatePath = path.join(currentDir, 'package.json');
+            try {
+                await fs.access(candidatePath);
+                packageJsonPath = candidatePath;
+                break;
+            }
+            catch {
+                // File doesn't exist, try parent directory
+                const parentDir = path.dirname(currentDir);
+                if (parentDir === currentDir) {
+                    // We've reached the root
+                    break;
+                }
+                currentDir = parentDir;
+            }
+        }
+        if (!packageJsonPath) {
+            throw new Error('Could not find package.json in current directory or any parent directory');
+        }
+        const packageContent = await fs.readFile(packageJsonPath, 'utf-8');
+        const packageData = JSON.parse(packageContent);
+        return packageData.version;
+    }
+    /**
+     * Enhanced semantic version comparison supporting pre-release versions
+     * Returns: -1 if v1 < v2, 0 if v1 == v2, 1 if v1 > v2
+     */
+    compareVersions(version1, version2) {
+        // Normalize versions by removing 'v' prefix
+        const v1 = version1.replace(/^v/, '');
+        const v2 = version2.replace(/^v/, '');
+        // Split version and pre-release parts
+        const [v1main, v1pre] = v1.split('-');
+        const [v2main, v2pre] = v2.split('-');
+        // Compare main version parts (x.y.z)
+        const v1parts = v1main.split('.').map(part => parseInt(part) || 0);
+        const v2parts = v2main.split('.').map(part => parseInt(part) || 0);
+        const maxLength = Math.max(v1parts.length, v2parts.length);
+        for (let i = 0; i < maxLength; i++) {
+            const v1part = v1parts[i] || 0;
+            const v2part = v2parts[i] || 0;
+            if (v1part < v2part)
+                return -1;
+            if (v1part > v2part)
+                return 1;
+        }
+        // If main versions are equal, compare pre-release versions
+        // Version without pre-release is greater than version with pre-release
+        if (!v1pre && v2pre)
+            return 1; // 1.0.0 > 1.0.0-beta
+        if (v1pre && !v2pre)
+            return -1; // 1.0.0-beta < 1.0.0
+        if (!v1pre && !v2pre)
+            return 0; // 1.0.0 == 1.0.0
+        // Both have pre-release, compare lexicographically
+        return v1pre.localeCompare(v2pre);
+    }
+    /**
+     * Parse version from dependency output
+     */
+    parseVersionFromOutput(output, tool) {
+        // Git version output: "git version 2.39.2"
+        // npm version output: "8.19.2" or JSON with version info
+        if (tool === 'git') {
+            const match = output.match(/git version (\d+\.\d+\.\d+)/);
+            return match ? match[1] : null;
+        }
+        else if (tool === 'npm') {
+            // npm might return just the version number or JSON
+            const cleanOutput = output.trim();
+            if (cleanOutput.match(/^\d+\.\d+\.\d+/)) {
+                return cleanOutput.split('\n')[0]; // First line if multiple lines
+            }
+            // Try to parse as JSON if it looks like JSON
+            try {
+                const parsed = JSON.parse(cleanOutput);
+                return parsed.npm || parsed.version || null;
+            }
+            catch {
+                // If not JSON, try to extract version pattern
+                const match = cleanOutput.match(/(\d+\.\d+\.\d+)/);
+                return match ? match[1] : null;
+            }
+        }
+        return null;
+    }
+    /**
+     * Validate that a dependency version meets requirements
+     */
+    validateDependencyVersion(actualVersion, requirements, toolName) {
+        const minComparison = this.compareVersions(actualVersion, requirements.minimum);
+        const maxComparison = this.compareVersions(actualVersion, requirements.maximum);
+        // Check if version is below minimum
+        if (minComparison < 0) {
+            return {
+                valid: false,
+                error: `${toolName} version ${actualVersion} is below minimum required version ${requirements.minimum}. Please upgrade ${toolName}.`
+            };
+        }
+        // Check if version is above maximum tested
+        if (maxComparison > 0) {
+            return {
+                valid: true,
+                warning: `${toolName} version ${actualVersion} is above maximum tested version ${requirements.maximum}. Some features may not work as expected.`
+            };
+        }
+        // Check if not at recommended version
+        const recComparison = this.compareVersions(actualVersion, requirements.recommended);
+        if (recComparison !== 0) {
+            return {
+                valid: true,
+                warning: `${toolName} version ${actualVersion} works but ${requirements.recommended} is recommended for optimal stability.`
+            };
+        }
+        // Version is perfect
+        return { valid: true };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"VersionManager.js","sourceRoot":"","sources":["../../../../src/update/VersionManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Version management and comparison utilities\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\n\nexport class VersionManager {\n  /**\n   * Get current version from package.json\n   */\n  async getCurrentVersion(): Promise<string> {\n    // Use process.cwd() as a base, then search upward for package.json\n    let currentDir = process.cwd();\n    let packageJsonPath: string | null = null;\n    \n    // Search up to 5 levels for package.json\n    for (let i = 0; i < 5; i++) {\n      const candidatePath = path.join(currentDir, 'package.json');\n      try {\n        await fs.access(candidatePath);\n        packageJsonPath = candidatePath;\n        break;\n      } catch {\n        // File doesn't exist, try parent directory\n        const parentDir = path.dirname(currentDir);\n        if (parentDir === currentDir) {\n          // We've reached the root\n          break;\n        }\n        currentDir = parentDir;\n      }\n    }\n    \n    if (!packageJsonPath) {\n      throw new Error('Could not find package.json in current directory or any parent directory');\n    }\n    \n    const packageContent = await fs.readFile(packageJsonPath, 'utf-8');\n    const packageData = JSON.parse(packageContent);\n    return packageData.version;\n  }\n  \n  /**\n   * Enhanced semantic version comparison supporting pre-release versions\n   * Returns: -1 if v1 < v2, 0 if v1 == v2, 1 if v1 > v2\n   */\n  compareVersions(version1: string, version2: string): number {\n    // Normalize versions by removing 'v' prefix\n    const v1 = version1.replace(/^v/, '');\n    const v2 = version2.replace(/^v/, '');\n    \n    // Split version and pre-release parts\n    const [v1main, v1pre] = v1.split('-');\n    const [v2main, v2pre] = v2.split('-');\n    \n    // Compare main version parts (x.y.z)\n    const v1parts = v1main.split('.').map(part => parseInt(part) || 0);\n    const v2parts = v2main.split('.').map(part => parseInt(part) || 0);\n    \n    const maxLength = Math.max(v1parts.length, v2parts.length);\n    for (let i = 0; i < maxLength; i++) {\n      const v1part = v1parts[i] || 0;\n      const v2part = v2parts[i] || 0;\n      \n      if (v1part < v2part) return -1;\n      if (v1part > v2part) return 1;\n    }\n    \n    // If main versions are equal, compare pre-release versions\n    // Version without pre-release is greater than version with pre-release\n    if (!v1pre && v2pre) return 1;   // 1.0.0 > 1.0.0-beta\n    if (v1pre && !v2pre) return -1;  // 1.0.0-beta < 1.0.0\n    if (!v1pre && !v2pre) return 0;  // 1.0.0 == 1.0.0\n    \n    // Both have pre-release, compare lexicographically\n    return v1pre.localeCompare(v2pre);\n  }\n  \n  /**\n   * Parse version from dependency output\n   */\n  parseVersionFromOutput(output: string, tool: string): string | null {\n    // Git version output: \"git version 2.39.2\"\n    // npm version output: \"8.19.2\" or JSON with version info\n    \n    if (tool === 'git') {\n      const match = output.match(/git version (\\d+\\.\\d+\\.\\d+)/);\n      return match ? match[1] : null;\n    } else if (tool === 'npm') {\n      // npm might return just the version number or JSON\n      const cleanOutput = output.trim();\n      if (cleanOutput.match(/^\\d+\\.\\d+\\.\\d+/)) {\n        return cleanOutput.split('\\n')[0]; // First line if multiple lines\n      }\n      // Try to parse as JSON if it looks like JSON\n      try {\n        const parsed = JSON.parse(cleanOutput);\n        return parsed.npm || parsed.version || null;\n      } catch {\n        // If not JSON, try to extract version pattern\n        const match = cleanOutput.match(/(\\d+\\.\\d+\\.\\d+)/);\n        return match ? match[1] : null;\n      }\n    }\n    \n    return null;\n  }\n  \n  /**\n   * Validate that a dependency version meets requirements\n   */\n  validateDependencyVersion(\n    actualVersion: string, \n    requirements: { minimum: string; maximum: string; recommended: string },\n    toolName: string\n  ): { valid: boolean; warning?: string; error?: string } {\n    const minComparison = this.compareVersions(actualVersion, requirements.minimum);\n    const maxComparison = this.compareVersions(actualVersion, requirements.maximum);\n    \n    // Check if version is below minimum\n    if (minComparison < 0) {\n      return {\n        valid: false,\n        error: `${toolName} version ${actualVersion} is below minimum required version ${requirements.minimum}. Please upgrade ${toolName}.`\n      };\n    }\n    \n    // Check if version is above maximum tested\n    if (maxComparison > 0) {\n      return {\n        valid: true,\n        warning: `${toolName} version ${actualVersion} is above maximum tested version ${requirements.maximum}. Some features may not work as expected.`\n      };\n    }\n    \n    // Check if not at recommended version\n    const recComparison = this.compareVersions(actualVersion, requirements.recommended);\n    if (recComparison !== 0) {\n      return {\n        valid: true,\n        warning: `${toolName} version ${actualVersion} works but ${requirements.recommended} is recommended for optimal stability.`\n      };\n    }\n    \n    // Version is perfect\n    return { valid: true };\n  }\n}"]}

package/dist/test/src/update/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Update module exports
+ */
+export * from './VersionManager.js';
+export * from './UpdateChecker.js';
+export * from './DependencyChecker.js';
+export * from './BackupManager.js';
+export * from './UpdateManager.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/test/src/update/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/update/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC"}

package/dist/test/src/update/index.js

@@ -0,0 +1,9 @@
+/**
+ * Update module exports
+ */
+export * from './VersionManager.js';
+export * from './UpdateChecker.js';
+export * from './DependencyChecker.js';
+export * from './BackupManager.js';
+export * from './UpdateManager.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXBkYXRlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBVcGRhdGUgbW9kdWxlIGV4cG9ydHNcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL1ZlcnNpb25NYW5hZ2VyLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vVXBkYXRlQ2hlY2tlci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL0RlcGVuZGVuY3lDaGVja2VyLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vQmFja3VwTWFuYWdlci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL1VwZGF0ZU1hbmFnZXIuanMnOyJdfQ==

package/dist/test/src/utils/filesystem.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Filesystem and string manipulation utilities
+ */
+/**
+ * Generate an anonymous ID for users without identity
+ */
+export declare function generateAnonymousId(): string;
+export declare function generateUniqueId(personaName: string, author?: string): string;
+/**
+ * Convert text to URL-safe slug
+ */
+export declare function slugify(text: string): string;
+/**
+ * Ensure a directory exists, create if it doesn't
+ */
+export declare function ensureDirectory(dirPath: string): Promise<void>;
+/**
+ * Check if a file exists
+ */
+export declare function fileExists(filePath: string): Promise<boolean>;
+/**
+ * Get file size in bytes
+ */
+export declare function getFileSize(filePath: string): Promise<number>;
+/**
+ * Create a backup of a directory
+ */
+export declare function createBackup(sourcePath: string, backupPath: string): Promise<void>;
+//# sourceMappingURL=filesystem.d.ts.map

package/dist/test/src/utils/filesystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../../../src/utils/filesystem.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAK5C;AAQD,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAkB7E;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAW5C;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAMpE;AAED;;GAEG;AACH,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOnE;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAGnE;AAED;;GAEG;AACH,wBAAsB,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAOxF"}