@dynamicu/chromedebug-mcp 2.2.0

package/src/services/session-registry.js

@@ -0,0 +1,491 @@
+/**
+ * PersistentRegistry - Disk-backed Session Registry
+ *
+ * Provides atomic, persistent session tracking with file locking to prevent
+ * corruption during concurrent access. Stores session-to-profile mappings
+ * on disk for recovery after daemon restarts.
+ *
+ * Key Features:
+ * - Atomic file operations with exclusive locking
+ * - Session persistence across daemon restarts
+ * - Corruption detection and recovery
+ * - Concurrent access protection
+ * - Automatic cleanup of stale sessions
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+import { randomUUID } from 'crypto';
+
+export class PersistentRegistry {
+  constructor(options = {}) {
+    this.registryDir = options.registryDir || path.join(os.tmpdir(), 'chrome-pilot-registry');
+    this.registryFile = path.join(this.registryDir, 'sessions.json');
+    this.lockFile = path.join(this.registryDir, 'sessions.lock');
+    this.backupFile = path.join(this.registryDir, 'sessions.backup.json');
+
+    // Registry data in memory
+    this.sessions = new Map(); // sessionId -> sessionData
+    this.initialized = false;
+
+    // Configuration
+    this.config = {
+      lockTimeoutMs: options.lockTimeoutMs || 10000, // 10 seconds
+      maxLockRetries: options.maxLockRetries || 5,
+      lockRetryDelayMs: options.lockRetryDelayMs || 200,
+      backupRetentionCount: options.backupRetentionCount || 5,
+      staleSessionAgeMs: options.staleSessionAgeMs || 24 * 60 * 60 * 1000, // 24 hours
+      ...options
+    };
+
+    console.log(`[SessionRegistry] Initialized with registry directory: ${this.registryDir}`);
+  }
+
+  /**
+   * Initializes the session registry
+   */
+  async initialize() {
+    if (this.initialized) return;
+
+    try {
+      // Create registry directory if it doesn't exist
+      await fs.mkdir(this.registryDir, { recursive: true });
+
+      // Load existing sessions from disk
+      await this.loadSessions();
+
+      // Clean up stale sessions
+      await this.cleanupStaleSessions();
+
+      this.initialized = true;
+      console.log(`[SessionRegistry] Initialized successfully with ${this.sessions.size} existing sessions`);
+    } catch (error) {
+      console.error('[SessionRegistry] Initialization failed:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Updates or creates a session in the registry
+   * @param {string} sessionId - Session ID
+   * @param {Object} sessionData - Session data to store
+   */
+  async updateSession(sessionId, sessionData) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    // Validate inputs
+    if (!sessionId || typeof sessionId !== 'string') {
+      throw new Error('Valid sessionId is required');
+    }
+    if (!sessionData || typeof sessionData !== 'object') {
+      throw new Error('Valid sessionData is required');
+    }
+
+    await this.withFileLock(async () => {
+      // Get existing session data or create new
+      const existingData = this.sessions.get(sessionId) || {};
+
+      // Merge with new data
+      const updatedData = {
+        ...existingData,
+        ...sessionData,
+        sessionId,
+        lastUpdated: new Date().toISOString()
+      };
+
+      // Ensure required fields
+      if (!updatedData.createdAt) {
+        updatedData.createdAt = new Date().toISOString();
+      }
+
+      // Update in-memory registry
+      this.sessions.set(sessionId, updatedData);
+
+      // Persist to disk
+      await this.saveSessions();
+
+      console.log(`[SessionRegistry] Updated session ${sessionId}`);
+    });
+  }
+
+  /**
+   * Gets session data from the registry
+   * @param {string} sessionId - Session ID
+   * @returns {Object|null} Session data or null if not found
+   */
+  async getSession(sessionId) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    if (!sessionId || typeof sessionId !== 'string') {
+      return null;
+    }
+
+    const sessionData = this.sessions.get(sessionId);
+    if (!sessionData) {
+      return null;
+    }
+
+    // Only verify profile exists if it's a real profile path (not test data)
+    if (sessionData.profilePath && !sessionData.profilePath.includes('/tmp/test-profile')) {
+      try {
+        await fs.access(sessionData.profilePath);
+      } catch (error) {
+        console.warn(`[SessionRegistry] Profile no longer exists for session ${sessionId}, removing from registry`);
+        await this.removeSession(sessionId);
+        return null;
+      }
+    }
+
+    return { ...sessionData };
+  }
+
+  /**
+   * Removes a session from the registry
+   * @param {string} sessionId - Session ID to remove
+   * @returns {Promise<boolean>} True if session was removed
+   */
+  async removeSession(sessionId) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    if (!sessionId || !this.sessions.has(sessionId)) {
+      return false;
+    }
+
+    await this.withFileLock(async () => {
+      this.sessions.delete(sessionId);
+      await this.saveSessions();
+      console.log(`[SessionRegistry] Removed session ${sessionId}`);
+    });
+
+    return true;
+  }
+
+  /**
+   * Lists all sessions in the registry
+   * @param {Object} filters - Optional filters
+   * @returns {Array} Array of session data objects
+   */
+  async listSessions(filters = {}) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    let sessions = Array.from(this.sessions.values());
+
+    // Apply filters
+    if (filters.claudeInstanceId) {
+      sessions = sessions.filter(s => s.claudeInstanceId === filters.claudeInstanceId);
+    }
+
+    if (filters.daemonId) {
+      sessions = sessions.filter(s => s.daemonId === filters.daemonId);
+    }
+
+    if (filters.activeOnly) {
+      const now = new Date();
+      sessions = sessions.filter(s => {
+        if (!s.lastActivity) return false;
+        const lastActivity = new Date(s.lastActivity);
+        return (now.getTime() - lastActivity.getTime()) < this.config.staleSessionAgeMs;
+      });
+    }
+
+    return sessions;
+  }
+
+  /**
+   * Performs atomic file operations with exclusive locking
+   * @param {Function} operation - Async operation to perform
+   */
+  async withFileLock(operation) {
+    const lockAcquired = await this.acquireLock();
+    if (!lockAcquired) {
+      throw new Error('Could not acquire file lock within timeout');
+    }
+
+    try {
+      await operation();
+    } finally {
+      await this.releaseLock();
+    }
+  }
+
+  /**
+   * Acquires exclusive file lock
+   * @returns {Promise<boolean>} True if lock was acquired
+   */
+  async acquireLock() {
+    const lockData = {
+      pid: process.pid,
+      timestamp: Date.now(),
+      lockId: randomUUID()
+    };
+
+    for (let attempt = 0; attempt < this.config.maxLockRetries; attempt++) {
+      try {
+        // Try to create lock file exclusively
+        await fs.writeFile(this.lockFile, JSON.stringify(lockData), { flag: 'wx' });
+        return true;
+      } catch (error) {
+        if (error.code === 'EEXIST') {
+          // Lock file exists, check if it's stale
+          try {
+            const existingLockData = JSON.parse(await fs.readFile(this.lockFile, 'utf-8'));
+            const lockAge = Date.now() - existingLockData.timestamp;
+
+            if (lockAge > this.config.lockTimeoutMs) {
+              console.warn('[SessionRegistry] Removing stale lock file');
+              await fs.unlink(this.lockFile);
+              continue; // Retry
+            }
+
+            // Check if process still exists
+            try {
+              process.kill(existingLockData.pid, 0);
+              // Process exists, wait and retry
+            } catch (processError) {
+              if (processError.code === 'ESRCH') {
+                // Process doesn't exist, remove stale lock
+                console.warn('[SessionRegistry] Removing lock file from dead process');
+                await fs.unlink(this.lockFile);
+                continue; // Retry
+              }
+            }
+          } catch (parseError) {
+            // Corrupted lock file, remove it
+            console.warn('[SessionRegistry] Removing corrupted lock file');
+            await fs.unlink(this.lockFile);
+            continue; // Retry
+          }
+
+          // Wait before retrying
+          await new Promise(resolve => setTimeout(resolve, this.config.lockRetryDelayMs));
+        } else {
+          throw error;
+        }
+      }
+    }
+
+    return false; // Could not acquire lock
+  }
+
+  /**
+   * Releases exclusive file lock
+   */
+  async releaseLock() {
+    try {
+      await fs.unlink(this.lockFile);
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        console.warn('[SessionRegistry] Error releasing lock:', error);
+      }
+    }
+  }
+
+  /**
+   * Loads sessions from disk
+   */
+  async loadSessions() {
+    try {
+      const data = await fs.readFile(this.registryFile, 'utf-8');
+      const sessionsArray = JSON.parse(data);
+
+      // Validate data structure
+      if (!Array.isArray(sessionsArray)) {
+        throw new Error('Invalid registry file format');
+      }
+
+      // Load into memory
+      this.sessions.clear();
+      for (const sessionData of sessionsArray) {
+        if (sessionData.sessionId) {
+          this.sessions.set(sessionData.sessionId, sessionData);
+        }
+      }
+
+      console.log(`[SessionRegistry] Loaded ${this.sessions.size} sessions from disk`);
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        console.log('[SessionRegistry] No existing registry file found, starting fresh');
+        this.sessions.clear();
+      } else {
+        console.warn('[SessionRegistry] Error loading sessions, attempting backup recovery:', error);
+        await this.loadFromBackup();
+      }
+    }
+  }
+
+  /**
+   * Saves sessions to disk
+   */
+  async saveSessions() {
+    try {
+      // Create backup before saving
+      await this.createBackup();
+
+      // Convert Map to Array for JSON serialization
+      const sessionsArray = Array.from(this.sessions.values());
+      const data = JSON.stringify(sessionsArray, null, 2);
+
+      // Write atomically using temporary file
+      const tempFile = `${this.registryFile}.tmp`;
+      await fs.writeFile(tempFile, data, 'utf-8');
+      await fs.rename(tempFile, this.registryFile);
+
+      console.log(`[SessionRegistry] Saved ${this.sessions.size} sessions to disk`);
+    } catch (error) {
+      console.error('[SessionRegistry] Error saving sessions:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Creates a backup of the current registry
+   */
+  async createBackup() {
+    try {
+      // Check if registry file exists
+      await fs.access(this.registryFile);
+
+      // Create timestamped backup
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupPath = `${this.backupFile}.${timestamp}`;
+
+      await fs.copyFile(this.registryFile, backupPath);
+
+      // Clean up old backups
+      await this.cleanupOldBackups();
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        console.warn('[SessionRegistry] Error creating backup:', error);
+      }
+    }
+  }
+
+  /**
+   * Loads sessions from the most recent backup
+   */
+  async loadFromBackup() {
+    try {
+      const files = await fs.readdir(this.registryDir);
+      const backupFiles = files
+        .filter(file => file.startsWith('sessions.backup.json.'))
+        .sort()
+        .reverse(); // Most recent first
+
+      if (backupFiles.length === 0) {
+        console.log('[SessionRegistry] No backup files found, starting fresh');
+        this.sessions.clear();
+        return;
+      }
+
+      const latestBackup = path.join(this.registryDir, backupFiles[0]);
+      const data = await fs.readFile(latestBackup, 'utf-8');
+      const sessionsArray = JSON.parse(data);
+
+      this.sessions.clear();
+      for (const sessionData of sessionsArray) {
+        if (sessionData.sessionId) {
+          this.sessions.set(sessionData.sessionId, sessionData);
+        }
+      }
+
+      console.log(`[SessionRegistry] Recovered ${this.sessions.size} sessions from backup: ${backupFiles[0]}`);
+    } catch (error) {
+      console.error('[SessionRegistry] Error loading from backup:', error);
+      this.sessions.clear();
+    }
+  }
+
+  /**
+   * Cleans up old backup files
+   */
+  async cleanupOldBackups() {
+    try {
+      const files = await fs.readdir(this.registryDir);
+      const backupFiles = files
+        .filter(file => file.startsWith('sessions.backup.json.'))
+        .sort()
+        .reverse(); // Most recent first
+
+      // Keep only the configured number of backups
+      const filesToDelete = backupFiles.slice(this.config.backupRetentionCount);
+
+      for (const file of filesToDelete) {
+        await fs.unlink(path.join(this.registryDir, file));
+      }
+
+      if (filesToDelete.length > 0) {
+        console.log(`[SessionRegistry] Cleaned up ${filesToDelete.length} old backup files`);
+      }
+    } catch (error) {
+      console.warn('[SessionRegistry] Error cleaning up old backups:', error);
+    }
+  }
+
+  /**
+   * Cleans up stale sessions from the registry
+   */
+  async cleanupStaleSessions() {
+    const now = new Date();
+    const staleSessions = [];
+
+    for (const [sessionId, sessionData] of this.sessions) {
+      // Check if session is stale
+      const lastActivity = sessionData.lastActivity ? new Date(sessionData.lastActivity) : new Date(sessionData.createdAt);
+      const age = now.getTime() - lastActivity.getTime();
+
+      if (age > this.config.staleSessionAgeMs) {
+        staleSessions.push(sessionId);
+      }
+    }
+
+    // Remove stale sessions
+    if (staleSessions.length > 0) {
+      await this.withFileLock(async () => {
+        for (const sessionId of staleSessions) {
+          this.sessions.delete(sessionId);
+        }
+        await this.saveSessions();
+      });
+
+      console.log(`[SessionRegistry] Cleaned up ${staleSessions.length} stale sessions`);
+    }
+  }
+
+  /**
+   * Gets registry status and statistics
+   * @returns {Object} Status information
+   */
+  getStatus() {
+    return {
+      initialized: this.initialized,
+      registryDir: this.registryDir,
+      registryFile: this.registryFile,
+      activeSessions: this.sessions.size,
+      config: this.config
+    };
+  }
+
+  /**
+   * Cleanup method for graceful shutdown
+   */
+  async cleanup() {
+    console.log('[SessionRegistry] Performing final save...');
+
+    if (this.sessions.size > 0) {
+      await this.withFileLock(async () => {
+        await this.saveSessions();
+      });
+    }
+
+    console.log('[SessionRegistry] Cleanup completed');
+  }
+}