@dollhousemcp/mcp-server 1.3.0

package/dist/update/BackupManager.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Manage backups during updates
+ */
+export interface BackupInfo {
+    path: string;
+    timestamp: string;
+    version?: string;
+}
+export declare class BackupManager {
+    private rootDir;
+    private backupsDir;
+    constructor(rootDir?: string);
+    /**
+     * Check if the directory contains production files
+     */
+    private hasProductionFiles;
+    /**
+     * Check if this appears to be a safe test directory
+     */
+    private isSafeTestDirectory;
+    /**
+     * Check if running in a Docker container
+     */
+    private isDockerEnvironment;
+    /**
+     * Create a backup of the current installation
+     */
+    createBackup(version?: string): Promise<BackupInfo>;
+    /**
+     * List available backups
+     */
+    listBackups(): Promise<BackupInfo[]>;
+    /**
+     * Get the most recent backup
+     */
+    getLatestBackup(): Promise<BackupInfo | null>;
+    /**
+     * Restore from a backup
+     */
+    restoreBackup(backupPath: string): Promise<void>;
+    /**
+     * Clean up old backups (keep the 5 most recent)
+     */
+    cleanupOldBackups(keepCount?: number): Promise<number>;
+}
+//# sourceMappingURL=BackupManager.d.ts.map

package/dist/update/BackupManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BackupManager.d.ts","sourceRoot":"","sources":["../../src/update/BackupManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,UAAU,CAAS;gBAEf,OAAO,CAAC,EAAE,MAAM;IAyB5B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IA8B1B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAY3B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAwB3B;;OAEG;IACG,YAAY,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IA4EzD;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;IAmC1C;;OAEG;IACG,eAAe,IAAI,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAKnD;;OAEG;IACG,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoCtD;;OAEG;IACG,iBAAiB,CAAC,SAAS,GAAE,MAAU,GAAG,OAAO,CAAC,MAAM,CAAC;CAmBhE"}

package/dist/update/BackupManager.js

@@ -0,0 +1,261 @@
+/**
+ * Manage backups during updates
+ */
+import * as fs from 'fs/promises';
+import * as fsSync from 'fs';
+import * as path from 'path';
+import { safeExec } from '../utils/git.js';
+import { logger } from '../utils/logger.js';
+export class BackupManager {
+    rootDir;
+    backupsDir;
+    constructor(rootDir) {
+        // Validate rootDir parameter if provided
+        if (rootDir) {
+            // Prevent path traversal attacks first
+            if (rootDir.includes('../') || rootDir.includes('..\\')) {
+                throw new Error('rootDir cannot contain path traversal sequences');
+            }
+            // Then check if it's absolute
+            if (!path.isAbsolute(rootDir)) {
+                throw new Error('rootDir must be an absolute path');
+            }
+        }
+        // Allow override for testing, default to process.cwd()
+        this.rootDir = rootDir || process.cwd();
+        // Safety check: Don't allow operations on directories containing critical files
+        // This prevents accidental deletion of the actual project directory
+        if (this.hasProductionFiles() && !this.isSafeTestDirectory()) {
+            throw new Error('BackupManager cannot operate on production directory. Pass a safe test directory to the constructor.');
+        }
+        this.backupsDir = path.join(this.rootDir, "..", "dollhousemcp-backups");
+    }
+    /**
+     * Check if the directory contains production files
+     */
+    hasProductionFiles() {
+        try {
+            const productionIndicators = [
+                'package.json',
+                'tsconfig.json',
+                '.git',
+                'src',
+                'LICENSE'
+            ];
+            const files = fsSync.readdirSync(this.rootDir);
+            const hasProductionFile = productionIndicators.some(indicator => files.includes(indicator));
+            // Additional check: if package.json exists, check if it's a real project
+            if (hasProductionFile && files.includes('package.json')) {
+                const packageJsonPath = path.join(this.rootDir, 'package.json');
+                const packageJson = JSON.parse(fsSync.readFileSync(packageJsonPath, 'utf-8'));
+                // If it has a name and dependencies, it's likely a real project
+                return !!(packageJson.name && packageJson.dependencies);
+            }
+            return hasProductionFile;
+        }
+        catch {
+            // If we can't read the directory, assume it's safe
+            return false;
+        }
+    }
+    /**
+     * Check if this appears to be a safe test directory
+     */
+    isSafeTestDirectory() {
+        const safePaths = ['test', 'tmp', 'temp', '.test', '__test__'];
+        const dirPath = this.rootDir.toLowerCase();
+        // Check if running in Docker container
+        if (this.isDockerEnvironment()) {
+            return true; // Docker containers are immutable, updates don't apply
+        }
+        return safePaths.some(safe => dirPath.includes(safe));
+    }
+    /**
+     * Check if running in a Docker container
+     */
+    isDockerEnvironment() {
+        // Check common Docker indicators
+        if (process.env.DOLLHOUSE_DISABLE_UPDATES === 'true') {
+            return true;
+        }
+        // Check if running from /app directory (common Docker practice)
+        if (this.rootDir === '/app') {
+            return true;
+        }
+        // Check for Docker-specific files
+        try {
+            const hasDockerEnv = fsSync.existsSync('/.dockerenv');
+            if (hasDockerEnv) {
+                return true;
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return false;
+    }
+    /**
+     * Create a backup of the current installation
+     */
+    async createBackup(version) {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const backupName = `backup-${timestamp}`;
+        const backupPath = path.join(this.backupsDir, backupName);
+        // Ensure backups directory exists
+        await fs.mkdir(this.backupsDir, { recursive: true });
+        // Use git to create a clean copy (respecting .gitignore)
+        await safeExec('git', [
+            'archive',
+            '--format=tar',
+            'HEAD'
+        ], { cwd: this.rootDir }).then(async ({ stdout }) => {
+            // Create backup directory
+            await fs.mkdir(backupPath, { recursive: true });
+            // Extract tar to backup directory
+            const tarPath = path.join(backupPath, 'archive.tar');
+            await fs.writeFile(tarPath, stdout);
+            // Extract using tar command
+            await safeExec('tar', ['-xf', 'archive.tar'], { cwd: backupPath });
+            await fs.unlink(tarPath);
+        });
+        // Also backup node_modules if it exists
+        const nodeModulesPath = path.join(this.rootDir, 'node_modules');
+        try {
+            await fs.access(nodeModulesPath);
+            await safeExec('cp', ['-r', 'node_modules', backupPath], { cwd: this.rootDir });
+        }
+        catch {
+            // node_modules doesn't exist or copy failed, that's okay
+        }
+        // Backup all persona files (including user-created ones not in git)
+        const personasDir = path.join(this.rootDir, 'personas');
+        const backupPersonasDir = path.join(backupPath, 'personas');
+        try {
+            await fs.access(personasDir);
+            await fs.mkdir(backupPersonasDir, { recursive: true });
+            const personaFiles = await fs.readdir(personasDir);
+            for (const file of personaFiles) {
+                if (file.endsWith('.md')) {
+                    const sourcePath = path.join(personasDir, file);
+                    const destPath = path.join(backupPersonasDir, file);
+                    // Copy the file, overwriting if it already exists from git archive
+                    await fs.copyFile(sourcePath, destPath);
+                }
+            }
+        }
+        catch (error) {
+            // Log warning but don't fail the backup
+            logger.warn('Could not backup all personas:', error);
+        }
+        // Save backup metadata
+        const metadata = {
+            timestamp,
+            version,
+            createdAt: new Date().toISOString()
+        };
+        await fs.writeFile(path.join(backupPath, 'backup-metadata.json'), JSON.stringify(metadata, null, 2));
+        return {
+            path: backupPath,
+            timestamp,
+            version
+        };
+    }
+    /**
+     * List available backups
+     */
+    async listBackups() {
+        try {
+            const entries = await fs.readdir(this.backupsDir, { withFileTypes: true });
+            const backups = [];
+            for (const entry of entries) {
+                if (entry.isDirectory() && entry.name.startsWith('backup-')) {
+                    const backupPath = path.join(this.backupsDir, entry.name);
+                    const timestamp = entry.name.replace('backup-', '');
+                    // Try to read metadata
+                    let version;
+                    try {
+                        const metadataPath = path.join(backupPath, 'backup-metadata.json');
+                        const metadata = JSON.parse(await fs.readFile(metadataPath, 'utf-8'));
+                        version = metadata.version;
+                    }
+                    catch {
+                        // No metadata file, that's okay
+                    }
+                    backups.push({
+                        path: backupPath,
+                        timestamp,
+                        version
+                    });
+                }
+            }
+            // Sort by timestamp descending (newest first)
+            return backups.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Get the most recent backup
+     */
+    async getLatestBackup() {
+        const backups = await this.listBackups();
+        return backups.length > 0 ? backups[0] : null;
+    }
+    /**
+     * Restore from a backup
+     */
+    async restoreBackup(backupPath) {
+        // Verify backup exists
+        try {
+            await fs.access(backupPath);
+        }
+        catch {
+            throw new Error(`Backup not found: ${backupPath}`);
+        }
+        // Create a temporary directory for the current state
+        const tempDir = path.join(this.backupsDir, 'temp-current');
+        await fs.mkdir(tempDir, { recursive: true });
+        // Move current files to temp (except .git and node_modules)
+        const entries = await fs.readdir(this.rootDir);
+        for (const entry of entries) {
+            if (entry !== '.git' && entry !== 'node_modules' && entry !== 'dist') {
+                const sourcePath = path.join(this.rootDir, entry);
+                const destPath = path.join(tempDir, entry);
+                await fs.rename(sourcePath, destPath);
+            }
+        }
+        // Copy backup files to root
+        const backupEntries = await fs.readdir(backupPath);
+        for (const entry of backupEntries) {
+            if (entry !== 'backup-metadata.json' && entry !== '.git') {
+                const sourcePath = path.join(backupPath, entry);
+                const destPath = path.join(this.rootDir, entry);
+                await safeExec('cp', ['-r', sourcePath, destPath]);
+            }
+        }
+        // Clean up temp directory
+        await fs.rm(tempDir, { recursive: true, force: true });
+    }
+    /**
+     * Clean up old backups (keep the 5 most recent)
+     */
+    async cleanupOldBackups(keepCount = 5) {
+        const backups = await this.listBackups();
+        let deletedCount = 0;
+        if (backups.length > keepCount) {
+            const backupsToDelete = backups.slice(keepCount);
+            for (const backup of backupsToDelete) {
+                try {
+                    await fs.rm(backup.path, { recursive: true, force: true });
+                    deletedCount++;
+                }
+                catch (error) {
+                    logger.error(`Failed to delete backup ${backup.path}:`, error);
+                }
+            }
+        }
+        return deletedCount;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BackupManager.js","sourceRoot":"","sources":["../../src/update/BackupManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Manage backups during updates\n */\n\nimport * as fs from 'fs/promises';\nimport * as fsSync from 'fs';\nimport * as path from 'path';\nimport { safeExec } from '../utils/git.js';\nimport { logger } from '../utils/logger.js';\n\nexport interface BackupInfo {\n  path: string;\n  timestamp: string;\n  version?: string;\n}\n\nexport class BackupManager {\n  private rootDir: string;\n  private backupsDir: string;\n  \n  constructor(rootDir?: string) {\n    // Validate rootDir parameter if provided\n    if (rootDir) {\n      // Prevent path traversal attacks first\n      if (rootDir.includes('../') || rootDir.includes('..\\\\')) {\n        throw new Error('rootDir cannot contain path traversal sequences');\n      }\n      // Then check if it's absolute\n      if (!path.isAbsolute(rootDir)) {\n        throw new Error('rootDir must be an absolute path');\n      }\n    }\n    \n    // Allow override for testing, default to process.cwd()\n    this.rootDir = rootDir || process.cwd();\n    \n    // Safety check: Don't allow operations on directories containing critical files\n    // This prevents accidental deletion of the actual project directory\n    if (this.hasProductionFiles() && !this.isSafeTestDirectory()) {\n      throw new Error('BackupManager cannot operate on production directory. Pass a safe test directory to the constructor.');\n    }\n    \n    this.backupsDir = path.join(this.rootDir, \"..\", \"dollhousemcp-backups\");\n  }\n  \n  /**\n   * Check if the directory contains production files\n   */\n  private hasProductionFiles(): boolean {\n    try {\n      const productionIndicators = [\n        'package.json',\n        'tsconfig.json',\n        '.git',\n        'src',\n        'LICENSE'\n      ];\n      \n      const files = fsSync.readdirSync(this.rootDir);\n      const hasProductionFile = productionIndicators.some(indicator => \n        files.includes(indicator)\n      );\n      \n      // Additional check: if package.json exists, check if it's a real project\n      if (hasProductionFile && files.includes('package.json')) {\n        const packageJsonPath = path.join(this.rootDir, 'package.json');\n        const packageJson = JSON.parse(fsSync.readFileSync(packageJsonPath, 'utf-8'));\n        // If it has a name and dependencies, it's likely a real project\n        return !!(packageJson.name && packageJson.dependencies);\n      }\n      \n      return hasProductionFile;\n    } catch {\n      // If we can't read the directory, assume it's safe\n      return false;\n    }\n  }\n  \n  /**\n   * Check if this appears to be a safe test directory\n   */\n  private isSafeTestDirectory(): boolean {\n    const safePaths = ['test', 'tmp', 'temp', '.test', '__test__'];\n    const dirPath = this.rootDir.toLowerCase();\n    \n    // Check if running in Docker container\n    if (this.isDockerEnvironment()) {\n      return true; // Docker containers are immutable, updates don't apply\n    }\n    \n    return safePaths.some(safe => dirPath.includes(safe));\n  }\n  \n  /**\n   * Check if running in a Docker container\n   */\n  private isDockerEnvironment(): boolean {\n    // Check common Docker indicators\n    if (process.env.DOLLHOUSE_DISABLE_UPDATES === 'true') {\n      return true;\n    }\n    \n    // Check if running from /app directory (common Docker practice)\n    if (this.rootDir === '/app') {\n      return true;\n    }\n    \n    // Check for Docker-specific files\n    try {\n      const hasDockerEnv = fsSync.existsSync('/.dockerenv');\n      if (hasDockerEnv) {\n        return true;\n      }\n    } catch {\n      // Ignore errors\n    }\n    \n    return false;\n  }\n  \n  /**\n   * Create a backup of the current installation\n   */\n  async createBackup(version?: string): Promise<BackupInfo> {\n    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');\n    const backupName = `backup-${timestamp}`;\n    const backupPath = path.join(this.backupsDir, backupName);\n    \n    // Ensure backups directory exists\n    await fs.mkdir(this.backupsDir, { recursive: true });\n    \n    // Use git to create a clean copy (respecting .gitignore)\n    await safeExec('git', [\n      'archive',\n      '--format=tar',\n      'HEAD'\n    ], { cwd: this.rootDir }).then(async ({ stdout }) => {\n      // Create backup directory\n      await fs.mkdir(backupPath, { recursive: true });\n      \n      // Extract tar to backup directory\n      const tarPath = path.join(backupPath, 'archive.tar');\n      await fs.writeFile(tarPath, stdout);\n      \n      // Extract using tar command\n      await safeExec('tar', ['-xf', 'archive.tar'], { cwd: backupPath });\n      await fs.unlink(tarPath);\n    });\n    \n    // Also backup node_modules if it exists\n    const nodeModulesPath = path.join(this.rootDir, 'node_modules');\n    try {\n      await fs.access(nodeModulesPath);\n      await safeExec('cp', ['-r', 'node_modules', backupPath], { cwd: this.rootDir });\n    } catch {\n      // node_modules doesn't exist or copy failed, that's okay\n    }\n    \n    // Backup all persona files (including user-created ones not in git)\n    const personasDir = path.join(this.rootDir, 'personas');\n    const backupPersonasDir = path.join(backupPath, 'personas');\n    \n    try {\n      await fs.access(personasDir);\n      await fs.mkdir(backupPersonasDir, { recursive: true });\n      \n      const personaFiles = await fs.readdir(personasDir);\n      for (const file of personaFiles) {\n        if (file.endsWith('.md')) {\n          const sourcePath = path.join(personasDir, file);\n          const destPath = path.join(backupPersonasDir, file);\n          \n          // Copy the file, overwriting if it already exists from git archive\n          await fs.copyFile(sourcePath, destPath);\n        }\n      }\n    } catch (error) {\n      // Log warning but don't fail the backup\n      logger.warn('Could not backup all personas:', error);\n    }\n    \n    // Save backup metadata\n    const metadata = {\n      timestamp,\n      version,\n      createdAt: new Date().toISOString()\n    };\n    await fs.writeFile(\n      path.join(backupPath, 'backup-metadata.json'),\n      JSON.stringify(metadata, null, 2)\n    );\n    \n    return {\n      path: backupPath,\n      timestamp,\n      version\n    };\n  }\n  \n  /**\n   * List available backups\n   */\n  async listBackups(): Promise<BackupInfo[]> {\n    try {\n      const entries = await fs.readdir(this.backupsDir, { withFileTypes: true });\n      const backups: BackupInfo[] = [];\n      \n      for (const entry of entries) {\n        if (entry.isDirectory() && entry.name.startsWith('backup-')) {\n          const backupPath = path.join(this.backupsDir, entry.name);\n          const timestamp = entry.name.replace('backup-', '');\n          \n          // Try to read metadata\n          let version: string | undefined;\n          try {\n            const metadataPath = path.join(backupPath, 'backup-metadata.json');\n            const metadata = JSON.parse(await fs.readFile(metadataPath, 'utf-8'));\n            version = metadata.version;\n          } catch {\n            // No metadata file, that's okay\n          }\n          \n          backups.push({\n            path: backupPath,\n            timestamp,\n            version\n          });\n        }\n      }\n      \n      // Sort by timestamp descending (newest first)\n      return backups.sort((a, b) => b.timestamp.localeCompare(a.timestamp));\n    } catch {\n      return [];\n    }\n  }\n  \n  /**\n   * Get the most recent backup\n   */\n  async getLatestBackup(): Promise<BackupInfo | null> {\n    const backups = await this.listBackups();\n    return backups.length > 0 ? backups[0] : null;\n  }\n  \n  /**\n   * Restore from a backup\n   */\n  async restoreBackup(backupPath: string): Promise<void> {\n    // Verify backup exists\n    try {\n      await fs.access(backupPath);\n    } catch {\n      throw new Error(`Backup not found: ${backupPath}`);\n    }\n    \n    // Create a temporary directory for the current state\n    const tempDir = path.join(this.backupsDir, 'temp-current');\n    await fs.mkdir(tempDir, { recursive: true });\n    \n    // Move current files to temp (except .git and node_modules)\n    const entries = await fs.readdir(this.rootDir);\n    for (const entry of entries) {\n      if (entry !== '.git' && entry !== 'node_modules' && entry !== 'dist') {\n        const sourcePath = path.join(this.rootDir, entry);\n        const destPath = path.join(tempDir, entry);\n        await fs.rename(sourcePath, destPath);\n      }\n    }\n    \n    // Copy backup files to root\n    const backupEntries = await fs.readdir(backupPath);\n    for (const entry of backupEntries) {\n      if (entry !== 'backup-metadata.json' && entry !== '.git') {\n        const sourcePath = path.join(backupPath, entry);\n        const destPath = path.join(this.rootDir, entry);\n        await safeExec('cp', ['-r', sourcePath, destPath]);\n      }\n    }\n    \n    // Clean up temp directory\n    await fs.rm(tempDir, { recursive: true, force: true });\n  }\n  \n  /**\n   * Clean up old backups (keep the 5 most recent)\n   */\n  async cleanupOldBackups(keepCount: number = 5): Promise<number> {\n    const backups = await this.listBackups();\n    let deletedCount = 0;\n    \n    if (backups.length > keepCount) {\n      const backupsToDelete = backups.slice(keepCount);\n      \n      for (const backup of backupsToDelete) {\n        try {\n          await fs.rm(backup.path, { recursive: true, force: true });\n          deletedCount++;\n        } catch (error) {\n          logger.error(`Failed to delete backup ${backup.path}:`, error);\n        }\n      }\n    }\n    \n    return deletedCount;\n  }\n}"]}

package/dist/update/DependencyChecker.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Check and validate system dependencies
+ */
+import { VersionManager } from './VersionManager.js';
+export interface DependencyStatus {
+    git: {
+        installed: boolean;
+        version?: string;
+        valid?: boolean;
+        error?: string;
+        warning?: string;
+    };
+    npm: {
+        installed: boolean;
+        version?: string;
+        valid?: boolean;
+        error?: string;
+        warning?: string;
+    };
+}
+export declare class DependencyChecker {
+    private versionManager;
+    constructor(versionManager: VersionManager);
+    /**
+     * Check all system dependencies
+     */
+    checkDependencies(): Promise<DependencyStatus>;
+    /**
+     * Check Git installation and version
+     */
+    private checkGit;
+    /**
+     * Check npm installation and version
+     */
+    private checkNpm;
+    /**
+     * Format dependency status for display
+     */
+    formatDependencyStatus(status: DependencyStatus): string;
+}
+//# sourceMappingURL=DependencyChecker.d.ts.map

package/dist/update/DependencyChecker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DependencyChecker.d.ts","sourceRoot":"","sources":["../../src/update/DependencyChecker.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAGrD,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE;QACH,SAAS,EAAE,OAAO,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,GAAG,EAAE;QACH,SAAS,EAAE,OAAO,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,cAAc,CAAiB;gBAE3B,cAAc,EAAE,cAAc;IAI1C;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAYpD;;OAEG;YACW,QAAQ;IAiCtB;;OAEG;YACW,QAAQ;IAiCtB;;OAEG;IACH,sBAAsB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM;CA4CzD"}

package/dist/update/DependencyChecker.js

@@ -0,0 +1,132 @@
+/**
+ * Check and validate system dependencies
+ */
+import { safeExec } from '../utils/git.js';
+import { DEPENDENCY_REQUIREMENTS } from '../config/constants.js';
+export class DependencyChecker {
+    versionManager;
+    constructor(versionManager) {
+        this.versionManager = versionManager;
+    }
+    /**
+     * Check all system dependencies
+     */
+    async checkDependencies() {
+        const [gitStatus, npmStatus] = await Promise.all([
+            this.checkGit(),
+            this.checkNpm()
+        ]);
+        return {
+            git: gitStatus,
+            npm: npmStatus
+        };
+    }
+    /**
+     * Check Git installation and version
+     */
+    async checkGit() {
+        try {
+            const { stdout: gitOutput } = await safeExec('git', ['--version']);
+            const gitVersion = this.versionManager.parseVersionFromOutput(gitOutput, 'git');
+            if (!gitVersion) {
+                return {
+                    installed: true,
+                    error: 'Could not parse Git version from output'
+                };
+            }
+            const validation = this.versionManager.validateDependencyVersion(gitVersion, DEPENDENCY_REQUIREMENTS.git, 'Git');
+            return {
+                installed: true,
+                version: gitVersion,
+                valid: validation.valid,
+                error: validation.error,
+                warning: validation.warning
+            };
+        }
+        catch (error) {
+            return {
+                installed: false,
+                error: 'Git is not installed or not accessible in PATH'
+            };
+        }
+    }
+    /**
+     * Check npm installation and version
+     */
+    async checkNpm() {
+        try {
+            const { stdout: npmOutput } = await safeExec('npm', ['--version']);
+            const npmVersion = this.versionManager.parseVersionFromOutput(npmOutput, 'npm');
+            if (!npmVersion) {
+                return {
+                    installed: true,
+                    error: 'Could not parse npm version from output'
+                };
+            }
+            const validation = this.versionManager.validateDependencyVersion(npmVersion, DEPENDENCY_REQUIREMENTS.npm, 'npm');
+            return {
+                installed: true,
+                version: npmVersion,
+                valid: validation.valid,
+                error: validation.error,
+                warning: validation.warning
+            };
+        }
+        catch (error) {
+            return {
+                installed: false,
+                error: 'npm is not installed or not accessible in PATH'
+            };
+        }
+    }
+    /**
+     * Format dependency status for display
+     */
+    formatDependencyStatus(status) {
+        const lines = ['**Dependency Check Results:**\n'];
+        // Git status
+        lines.push('**Git:**');
+        if (!status.git.installed) {
+            lines.push(`❌ ${status.git.error}`);
+        }
+        else if (status.git.error) {
+            lines.push(`❌ Version ${status.git.version || 'unknown'} - ${status.git.error}`);
+        }
+        else if (status.git.warning) {
+            lines.push(`⚠️ Version ${status.git.version} - ${status.git.warning}`);
+        }
+        else {
+            lines.push(`✅ Version ${status.git.version} - OK`);
+        }
+        lines.push('');
+        // npm status
+        lines.push('**npm:**');
+        if (!status.npm.installed) {
+            lines.push(`❌ ${status.npm.error}`);
+        }
+        else if (status.npm.error) {
+            lines.push(`❌ Version ${status.npm.version || 'unknown'} - ${status.npm.error}`);
+        }
+        else if (status.npm.warning) {
+            lines.push(`⚠️ Version ${status.npm.version} - ${status.npm.warning}`);
+        }
+        else {
+            lines.push(`✅ Version ${status.npm.version} - OK`);
+        }
+        // Overall status
+        const hasErrors = status.git.error || status.npm.error;
+        const hasWarnings = status.git.warning || status.npm.warning;
+        lines.push('\n**Overall Status:**');
+        if (hasErrors) {
+            lines.push('❌ Some dependencies do not meet requirements. Update may fail.');
+        }
+        else if (hasWarnings) {
+            lines.push('⚠️ All dependencies work but some are not at recommended versions.');
+        }
+        else {
+            lines.push('✅ All dependencies meet requirements!');
+        }
+        return lines.join('\n');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DependencyChecker.js","sourceRoot":"","sources":["../../src/update/DependencyChecker.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Check and validate system dependencies\n */\n\nimport { safeExec } from '../utils/git.js';\nimport { VersionManager } from './VersionManager.js';\nimport { DEPENDENCY_REQUIREMENTS } from '../config/constants.js';\n\nexport interface DependencyStatus {\n  git: {\n    installed: boolean;\n    version?: string;\n    valid?: boolean;\n    error?: string;\n    warning?: string;\n  };\n  npm: {\n    installed: boolean;\n    version?: string;\n    valid?: boolean;\n    error?: string;\n    warning?: string;\n  };\n}\n\nexport class DependencyChecker {\n  private versionManager: VersionManager;\n  \n  constructor(versionManager: VersionManager) {\n    this.versionManager = versionManager;\n  }\n  \n  /**\n   * Check all system dependencies\n   */\n  async checkDependencies(): Promise<DependencyStatus> {\n    const [gitStatus, npmStatus] = await Promise.all([\n      this.checkGit(),\n      this.checkNpm()\n    ]);\n    \n    return {\n      git: gitStatus,\n      npm: npmStatus\n    };\n  }\n  \n  /**\n   * Check Git installation and version\n   */\n  private async checkGit(): Promise<DependencyStatus['git']> {\n    try {\n      const { stdout: gitOutput } = await safeExec('git', ['--version']);\n      const gitVersion = this.versionManager.parseVersionFromOutput(gitOutput, 'git');\n      \n      if (!gitVersion) {\n        return {\n          installed: true,\n          error: 'Could not parse Git version from output'\n        };\n      }\n      \n      const validation = this.versionManager.validateDependencyVersion(\n        gitVersion, \n        DEPENDENCY_REQUIREMENTS.git,\n        'Git'\n      );\n      \n      return {\n        installed: true,\n        version: gitVersion,\n        valid: validation.valid,\n        error: validation.error,\n        warning: validation.warning\n      };\n    } catch (error) {\n      return {\n        installed: false,\n        error: 'Git is not installed or not accessible in PATH'\n      };\n    }\n  }\n  \n  /**\n   * Check npm installation and version\n   */\n  private async checkNpm(): Promise<DependencyStatus['npm']> {\n    try {\n      const { stdout: npmOutput } = await safeExec('npm', ['--version']);\n      const npmVersion = this.versionManager.parseVersionFromOutput(npmOutput, 'npm');\n      \n      if (!npmVersion) {\n        return {\n          installed: true,\n          error: 'Could not parse npm version from output'\n        };\n      }\n      \n      const validation = this.versionManager.validateDependencyVersion(\n        npmVersion, \n        DEPENDENCY_REQUIREMENTS.npm,\n        'npm'\n      );\n      \n      return {\n        installed: true,\n        version: npmVersion,\n        valid: validation.valid,\n        error: validation.error,\n        warning: validation.warning\n      };\n    } catch (error) {\n      return {\n        installed: false,\n        error: 'npm is not installed or not accessible in PATH'\n      };\n    }\n  }\n  \n  /**\n   * Format dependency status for display\n   */\n  formatDependencyStatus(status: DependencyStatus): string {\n    const lines: string[] = ['**Dependency Check Results:**\\n'];\n    \n    // Git status\n    lines.push('**Git:**');\n    if (!status.git.installed) {\n      lines.push(`❌ ${status.git.error}`);\n    } else if (status.git.error) {\n      lines.push(`❌ Version ${status.git.version || 'unknown'} - ${status.git.error}`);\n    } else if (status.git.warning) {\n      lines.push(`⚠️ Version ${status.git.version} - ${status.git.warning}`);\n    } else {\n      lines.push(`✅ Version ${status.git.version} - OK`);\n    }\n    \n    lines.push('');\n    \n    // npm status\n    lines.push('**npm:**');\n    if (!status.npm.installed) {\n      lines.push(`❌ ${status.npm.error}`);\n    } else if (status.npm.error) {\n      lines.push(`❌ Version ${status.npm.version || 'unknown'} - ${status.npm.error}`);\n    } else if (status.npm.warning) {\n      lines.push(`⚠️ Version ${status.npm.version} - ${status.npm.warning}`);\n    } else {\n      lines.push(`✅ Version ${status.npm.version} - OK`);\n    }\n    \n    // Overall status\n    const hasErrors = status.git.error || status.npm.error;\n    const hasWarnings = status.git.warning || status.npm.warning;\n    \n    lines.push('\\n**Overall Status:**');\n    if (hasErrors) {\n      lines.push('❌ Some dependencies do not meet requirements. Update may fail.');\n    } else if (hasWarnings) {\n      lines.push('⚠️ All dependencies work but some are not at recommended versions.');\n    } else {\n      lines.push('✅ All dependencies meet requirements!');\n    }\n    \n    return lines.join('\\n');\n  }\n}"]}

package/dist/update/RateLimiter.d.ts

@@ -0,0 +1,80 @@
+/**
+ * RateLimiter - Implements rate limiting for API calls to prevent abuse
+ *
+ * Features:
+ * - Token bucket algorithm for flexible rate limiting
+ * - Configurable limits per time window
+ * - Memory-efficient implementation
+ * - Thread-safe for concurrent requests
+ */
+export interface RateLimiterConfig {
+    maxRequests: number;
+    windowMs: number;
+    minDelayMs?: number;
+}
+export interface RateLimitStatus {
+    allowed: boolean;
+    retryAfterMs?: number;
+    remainingTokens: number;
+    resetTime: Date;
+}
+export declare class RateLimiter {
+    private tokens;
+    private lastRefill;
+    private lastRequest;
+    private readonly maxTokens;
+    private readonly refillRate;
+    private readonly minDelay;
+    constructor(config: RateLimiterConfig);
+    /**
+     * Check if a request is allowed under the rate limit
+     * @returns Status object indicating if request is allowed
+     */
+    checkLimit(): RateLimitStatus;
+    /**
+     * Consume a token for an allowed request
+     * Should be called after checkLimit() returns allowed: true
+     */
+    consumeToken(): void;
+    /**
+     * Get current rate limit status without consuming a token
+     */
+    getStatus(): RateLimitStatus;
+    /**
+     * Reset the rate limiter to full capacity
+     * Useful for testing or manual intervention
+     */
+    reset(): void;
+    /**
+     * Refill tokens based on time elapsed
+     */
+    private refillTokens;
+    /**
+     * Calculate when the rate limit window will reset
+     */
+    private getResetTime;
+    /**
+     * Get human-readable rate limit information
+     */
+    toString(): string;
+}
+/**
+ * Factory function to create common rate limiters
+ */
+export declare class RateLimiterFactory {
+    /**
+     * GitHub API rate limiter (60 requests per hour for unauthenticated)
+     */
+    static createGitHubLimiter(): RateLimiter;
+    /**
+     * Conservative rate limiter for update checks
+     * Allows 10 checks per hour with 30 second minimum delay
+     */
+    static createUpdateCheckLimiter(): RateLimiter;
+    /**
+     * Strict rate limiter for sensitive operations
+     * Allows 5 requests per hour with 1 minute minimum delay
+     */
+    static createStrictLimiter(): RateLimiter;
+}
+//# sourceMappingURL=RateLimiter.d.ts.map

package/dist/update/RateLimiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RateLimiter.d.ts","sourceRoot":"","sources":["../../src/update/RateLimiter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAEtB,MAAM,EAAE,iBAAiB;IAsBrC;;;OAGG;IACH,UAAU,IAAI,eAAe;IA0C7B;;;OAGG;IACH,YAAY,IAAI,IAAI;IAUpB;;OAEG;IACH,SAAS,IAAI,eAAe;IAW5B;;;OAGG;IACH,KAAK,IAAI,IAAI;IAMb;;OAEG;IACH,OAAO,CAAC,YAAY;IAQpB;;OAEG;IACH,OAAO,CAAC,YAAY;IAOpB;;OAEG;IACH,QAAQ,IAAI,MAAM;CAKnB;AAED;;GAEG;AACH,qBAAa,kBAAkB;IAC7B;;OAEG;IACH,MAAM,CAAC,mBAAmB,IAAI,WAAW;IAQzC;;;OAGG;IACH,MAAM,CAAC,wBAAwB,IAAI,WAAW;IAQ9C;;;OAGG;IACH,MAAM,CAAC,mBAAmB,IAAI,WAAW;CAO1C"}