@dynamicu/chromedebug-mcp 2.2.0

package/chrome-extension/chrome-session-manager.js

@@ -0,0 +1,706 @@
+/**
+ * Chrome Extension Session Manager
+ *
+ * Manages recording sessions with lease-based state management to prevent
+ * stuck recordings and ensure reliable session lifecycle.
+ */
+
+class ChromeExtensionSessionManager {
+    constructor() {
+        this.STORAGE_KEY = 'chrome_pilot_recording_state';
+        this.LEASE_DURATION = 5000; // 5 seconds
+        this.MAX_DURATION = 30 * 60 * 1000; // 30 minutes
+
+        // Recording-only timer properties
+        this.activeRecordingTimer = null;  // Only active during recording
+        this.ACTIVE_LEASE_RENEWAL = 30000; // 30 seconds, only while recording
+
+        // In-memory state cache for synchronous access (v2.1.2: Race condition fix)
+        this._recordingStateCache = null;
+    }
+
+    /**
+     * Create a new recording session
+     * @param {Object} config - Session configuration
+     * @returns {Promise<Object>} Session creation result
+     */
+    async createSession(config = {}) {
+        const sessionConfig = this._mergeDefaultConfig(config);
+        const sessionId = this._generateSessionId();
+        const ownerId = this._generateOwnerId();
+        const currentTime = Date.now();
+
+        const recordingState = {
+            sessionId,
+            isRecording: false,
+            startTime: currentTime,
+            lastLeaseRenewal: currentTime,
+            leaseExpiresAt: currentTime + this.LEASE_DURATION,
+            maxDuration: sessionConfig.maxDuration,
+            frameCount: 0,
+            settings: sessionConfig,
+            status: 'active',
+            ownerId,
+            debugInfo: [{
+                event: 'session_created',
+                timestamp: currentTime,
+                data: { sessionId, ownerId }
+            }],
+            lastActivity: currentTime,
+            warningFlags: []
+        };
+
+        try {
+            await this._saveRecordingState(recordingState);
+            this._logDebug('Session created', { sessionId, ownerId });
+
+            return {
+                success: true,
+                sessionId,
+                ownerId,
+                state: recordingState
+            };
+        } catch (error) {
+            return this._createErrorResponse('STORAGE_ERROR', 'Failed to create session', error);
+        }
+    }
+
+    /**
+     * Start recording for a session
+     * @param {string} sessionId - Session identifier
+     * @param {string} ownerId - Owner identifier
+     * @returns {Promise<Object>} Start result
+     */
+    async startRecording(sessionId, ownerId) {
+        try {
+            const state = await this._getRecordingState();
+
+            if (!state || state.sessionId !== sessionId) {
+                return this._createErrorResponse('INVALID_STATE', 'Session not found');
+            }
+
+            if (state.ownerId !== ownerId) {
+                return this._createErrorResponse('INVALID_STATE', 'Unauthorized access to session');
+            }
+
+            if (state.isRecording) {
+                return this._createErrorResponse('INVALID_STATE', 'Recording already in progress');
+            }
+
+            const currentTime = Date.now();
+            const updatedState = {
+                ...state,
+                isRecording: true,
+                startTime: currentTime,
+                lastLeaseRenewal: currentTime,
+                leaseExpiresAt: currentTime + this.LEASE_DURATION,
+                status: 'active',
+                lastActivity: currentTime,
+                debugInfo: [...state.debugInfo, {
+                    event: 'recording_started',
+                    timestamp: currentTime,
+                    data: { sessionId }
+                }]
+            };
+
+            await this._saveRecordingState(updatedState);
+
+            // START polling ONLY for active recording
+            if (this.activeRecordingTimer) {
+                clearInterval(this.activeRecordingTimer);
+            }
+
+            this.activeRecordingTimer = setInterval(async () => {
+                // Renew lease for active recording
+                await this.renewLease({
+                    sessionId,
+                    ownerId,
+                    requestTime: Date.now()
+                });
+                // Clean up any other expired sessions
+                await this.cleanupExpiredSessions();
+            }, this.ACTIVE_LEASE_RENEWAL);
+
+            this._logDebug('Recording started with timer', { sessionId });
+
+            return {
+                success: true,
+                sessionId,
+                state: updatedState
+            };
+        } catch (error) {
+            return this._createErrorResponse('STORAGE_ERROR', 'Failed to start recording', error);
+        }
+    }
+
+    /**
+     * Renew lease for active session
+     * @param {Object} leaseRequest - Lease renewal request
+     * @returns {Promise<Object>} Lease response
+     */
+    async renewLease(leaseRequest) {
+        const { sessionId, ownerId, requestTime, renewalDuration = this.LEASE_DURATION } = leaseRequest;
+
+        try {
+            const state = await this._getRecordingState();
+
+            if (!state || state.sessionId !== sessionId) {
+                return {
+                    success: false,
+                    sessionId,
+                    error: 'Session not found'
+                };
+            }
+
+            if (state.ownerId !== ownerId) {
+                return {
+                    success: false,
+                    sessionId,
+                    error: 'Unauthorized lease renewal'
+                };
+            }
+
+            const currentTime = Date.now();
+            const sessionDuration = currentTime - state.startTime;
+
+            // Check if max duration exceeded
+            if (sessionDuration > state.maxDuration) {
+                await this._forceStopSession(sessionId, 'MAX_DURATION');
+                return {
+                    success: false,
+                    sessionId,
+                    error: 'Maximum duration exceeded',
+                    maxDurationExceeded: true
+                };
+            }
+
+            const newExpiration = currentTime + renewalDuration;
+            const updatedState = {
+                ...state,
+                lastLeaseRenewal: currentTime,
+                leaseExpiresAt: newExpiration,
+                lastActivity: currentTime,
+                debugInfo: [...state.debugInfo.slice(-20), { // Keep last 20 debug entries
+                    event: 'lease_renewed',
+                    timestamp: currentTime,
+                    data: { newExpiration, sessionDuration }
+                }]
+            };
+
+            // v2.1.2: UPDATE STATE SYNCHRONOUSLY to fix race condition
+            // Cache the state immediately BEFORE async storage save
+            // This ensures isSessionValid() sees the updated expiration immediately
+            this._recordingStateCache = updatedState;
+
+            // Then persist to storage (async is fine, cache is already updated)
+            await this._saveRecordingState(updatedState);
+
+            return {
+                success: true,
+                sessionId,
+                newExpiration,
+                maxDurationExceeded: false
+            };
+        } catch (error) {
+            return {
+                success: false,
+                sessionId,
+                error: 'Failed to renew lease: ' + error.message
+            };
+        }
+    }
+
+    /**
+     * Stop recording session
+     * @param {string} sessionId - Session identifier
+     * @param {string} ownerId - Owner identifier
+     * @returns {Promise<Object>} Stop result
+     */
+    async stopRecording(sessionId, ownerId) {
+        try {
+            const state = await this._getRecordingState();
+
+            if (!state || state.sessionId !== sessionId) {
+                return this._createErrorResponse('INVALID_STATE', 'Session not found');
+            }
+
+            if (state.ownerId !== ownerId) {
+                return this._createErrorResponse('INVALID_STATE', 'Unauthorized access to session');
+            }
+
+            const currentTime = Date.now();
+            const sessionDuration = currentTime - state.startTime;
+            const updatedState = {
+                ...state,
+                isRecording: false,
+                status: 'stopped',
+                lastActivity: currentTime,
+                debugInfo: [...state.debugInfo, {
+                    event: 'recording_stopped',
+                    timestamp: currentTime,
+                    data: { sessionId, sessionDuration, frameCount: state.frameCount }
+                }]
+            };
+
+            await this._saveRecordingState(updatedState);
+
+            // STOP the polling immediately
+            if (this.activeRecordingTimer) {
+                clearInterval(this.activeRecordingTimer);
+                this.activeRecordingTimer = null;
+            }
+
+            this._logDebug('Recording stopped with timer cleared', { sessionId, sessionDuration });
+
+            return {
+                success: true,
+                sessionId,
+                sessionDuration,
+                frameCount: state.frameCount,
+                state: updatedState
+            };
+        } catch (error) {
+            return this._createErrorResponse('STORAGE_ERROR', 'Failed to stop recording', error);
+        }
+    }
+
+    /**
+     * Force stop any active session (emergency cleanup)
+     * @param {string} reason - Reason for force stop
+     * @returns {Promise<Object>} Force stop result
+     */
+    async forceStopAll(reason = 'MANUAL_FORCE_STOP') {
+        try {
+            const state = await this._getRecordingState();
+
+            if (!state) {
+                return { success: true, message: 'No active session to stop' };
+            }
+
+            const result = await this._forceStopSession(state.sessionId, reason);
+            this._logDebug('Force stopped all sessions', { reason });
+
+            return result;
+        } catch (error) {
+            return this._createErrorResponse('STORAGE_ERROR', 'Failed to force stop', error);
+        }
+    }
+
+    /**
+     * Get current session state
+     * @returns {Promise<Object|null>} Current recording state
+     */
+    async getCurrentState() {
+        try {
+            return await this._getRecordingState();
+        } catch (error) {
+            this._logError('Failed to get current state', error);
+            return null;
+        }
+    }
+
+    /**
+     * Update frame count for session
+     * @param {string} sessionId - Session identifier
+     * @param {number} frameCount - New frame count
+     * @returns {Promise<boolean>} Update success
+     */
+    async updateFrameCount(sessionId, frameCount) {
+        try {
+            const state = await this._getRecordingState();
+
+            if (!state || state.sessionId !== sessionId) {
+                return false;
+            }
+
+            const updatedState = {
+                ...state,
+                frameCount,
+                lastActivity: Date.now()
+            };
+
+            await this._saveRecordingState(updatedState);
+            return true;
+        } catch (error) {
+            this._logError('Failed to update frame count', error);
+            return false;
+        }
+    }
+
+    /**
+     * Check if session is valid and active
+     * @param {string} sessionId - Session identifier
+     * @returns {Promise<Object>} Validity check result
+     */
+    async isSessionValid(sessionId) {
+        try {
+            const state = await this._getRecordingState();
+
+            if (!state || state.sessionId !== sessionId) {
+                return { valid: false, reason: 'Session not found' };
+            }
+
+            const currentTime = Date.now();
+            const isExpired = currentTime > state.leaseExpiresAt;
+            const isOverDuration = (currentTime - state.startTime) > state.maxDuration;
+
+            if (isExpired) {
+                await this._forceStopSession(sessionId, 'LEASE_EXPIRED');
+                return { valid: false, reason: 'Lease expired' };
+            }
+
+            if (isOverDuration) {
+                await this._forceStopSession(sessionId, 'MAX_DURATION');
+                return { valid: false, reason: 'Maximum duration exceeded' };
+            }
+
+            return {
+                valid: true,
+                state,
+                timeRemaining: state.maxDuration - (currentTime - state.startTime),
+                leaseTimeRemaining: state.leaseExpiresAt - currentTime
+            };
+        } catch (error) {
+            this._logError('Failed to validate session', error);
+            return { valid: false, reason: 'Validation error' };
+        }
+    }
+
+    /**
+     * Recover stuck sessions from previous runs
+     * Called during extension initialization and Chrome startup
+     * @returns {Promise<Object>} Recovery result
+     */
+    async recoverSessions() {
+        try {
+            const state = await this._getRecordingState();
+
+            if (!state) {
+                this._logDebug('No sessions to recover');
+                return { recovered: 0, message: 'No sessions to recover' };
+            }
+
+            const currentTime = Date.now();
+            const isExpired = currentTime > state.leaseExpiresAt;
+            const isOverDuration = (currentTime - state.startTime) > state.maxDuration;
+            // A session is only "stuck" if it's active, not recording, AND hasn't had activity for a reasonable time
+            // Allow active sessions to be idle for up to 30 minutes without being considered stuck
+            const isStuck = !state.isRecording && state.status === 'active' &&
+                           (currentTime - state.lastActivity) > (30 * 60 * 1000); // 30 minutes
+
+            // More conservative timeout: only clean up sessions that are truly abandoned
+            // - 24 hours of total inactivity for stopped sessions
+            // - 4 hours of inactivity for active sessions that aren't recording
+            const inactivityTime = currentTime - state.lastActivity;
+            const isTrulyAbandoned = state.status === 'stopped'
+                ? inactivityTime > (24 * 60 * 60 * 1000) // 24 hours for stopped sessions
+                : inactivityTime > (4 * 60 * 60 * 1000);  // 4 hours for active sessions
+
+            if (isExpired || isOverDuration || isStuck || isTrulyAbandoned) {
+                let reason = 'RECOVERY_CLEANUP';
+                if (isExpired) reason = 'LEASE_EXPIRED';
+                else if (isOverDuration) reason = 'MAX_DURATION_EXCEEDED';
+                else if (isStuck) reason = 'STUCK_SESSION';
+                else if (isTrulyAbandoned) reason = 'ABANDONED_SESSION';
+
+                await this._forceStopSession(state.sessionId, reason);
+
+                this._logDebug('Recovered stuck session', {
+                    sessionId: state.sessionId,
+                    reason,
+                    age: currentTime - state.startTime,
+                    lastActivity: currentTime - state.lastActivity
+                });
+
+                return {
+                    recovered: 1,
+                    message: `Recovered stuck session: ${state.sessionId}`,
+                    reason,
+                    sessionId: state.sessionId
+                };
+            }
+
+            this._logDebug('Session is healthy, no recovery needed', {
+                sessionId: state.sessionId,
+                status: state.status,
+                isRecording: state.isRecording
+            });
+
+            return { recovered: 0, message: 'Session is healthy', sessionId: state.sessionId };
+        } catch (error) {
+            this._logError('Session recovery failed', error);
+            return {
+                recovered: 0,
+                error: error.message,
+                message: 'Recovery failed due to error'
+            };
+        }
+    }
+
+    // Private Methods
+
+    /**
+     * Clean up expired sessions (only called during recording)
+     */
+    async cleanupExpiredSessions() {
+        try {
+            const state = await this._getRecordingState();
+            if (!state) return;
+
+            // Skip if already stopped (prevents repeated messages)
+            if (state.status === 'stopped') {
+                // Optionally remove very old stopped sessions (>1 hour)
+                const hourAgo = Date.now() - 3600000;
+                if (state.lastActivity < hourAgo) {
+                    await this._removeFromStorage();
+                }
+                return;
+            }
+
+            // Only process active expired sessions
+            const currentTime = Date.now();
+            if (currentTime > state.leaseExpiresAt) {
+                console.log('[ChromeSessionManager] Cleaning up expired session', {
+                    sessionId: state.sessionId
+                });
+                await this._forceStopSession(state.sessionId, 'LEASE_EXPIRED');
+            }
+        } catch (error) {
+            this._logError('Cleanup failed', error);
+        }
+    }
+
+    /**
+     * Perform cleanup of expired sessions (legacy method, now calls cleanupExpiredSessions)
+     */
+    async _performCleanup() {
+        await this.cleanupExpiredSessions();
+    }
+
+    /**
+     * Force stop a session
+     */
+    async _forceStopSession(sessionId, reason) {
+        const currentTime = Date.now();
+
+        try {
+            const state = await this._getRecordingState();
+
+            if (state && state.sessionId === sessionId) {
+                const updatedState = {
+                    ...state,
+                    isRecording: false,
+                    status: 'stopped',
+                    lastActivity: currentTime,
+                    debugInfo: [...state.debugInfo, {
+                        event: 'force_stopped',
+                        timestamp: currentTime,
+                        data: { reason, sessionId }
+                    }]
+                };
+
+                await this._saveRecordingState(updatedState);
+            }
+
+            return {
+                success: true,
+                sessionId,
+                reason,
+                stoppedAt: currentTime
+            };
+        } catch (error) {
+            return this._createErrorResponse('STORAGE_ERROR', 'Failed to force stop session', error);
+        }
+    }
+
+    /**
+     * Save recording state to Chrome storage
+     */
+    async _saveRecordingState(state) {
+        // v2.1.2: Update cache synchronously BEFORE async storage save
+        this._recordingStateCache = state;
+
+        return new Promise((resolve, reject) => {
+            chrome.storage.local.set({ [this.STORAGE_KEY]: state }, () => {
+                if (chrome.runtime.lastError) {
+                    reject(new Error(chrome.runtime.lastError.message));
+                } else {
+                    resolve();
+                }
+            });
+        });
+    }
+
+    /**
+     * Get recording state from Chrome storage
+     */
+    async _getRecordingState() {
+        // v2.1.2: Use cache first for synchronous lease checks (race condition fix)
+        if (this._recordingStateCache) {
+            return this._recordingStateCache;
+        }
+
+        // Otherwise fetch from storage
+        return new Promise((resolve, reject) => {
+            chrome.storage.local.get([this.STORAGE_KEY], (result) => {
+                if (chrome.runtime.lastError) {
+                    reject(new Error(chrome.runtime.lastError.message));
+                } else {
+                    const state = result[this.STORAGE_KEY] || null;
+                    // Cache the state for future synchronous access
+                    this._recordingStateCache = state;
+                    resolve(state);
+                }
+            });
+        });
+    }
+
+    /**
+     * Remove recording state from Chrome storage
+     */
+    async _removeFromStorage() {
+        // v2.1.2: Clear cache synchronously
+        this._recordingStateCache = null;
+
+        return new Promise((resolve, reject) => {
+            chrome.storage.local.remove([this.STORAGE_KEY], () => {
+                if (chrome.runtime.lastError) {
+                    reject(new Error(chrome.runtime.lastError.message));
+                } else {
+                    resolve();
+                }
+            });
+        });
+    }
+
+    /**
+     * Merge default configuration
+     */
+    _mergeDefaultConfig(config) {
+        return {
+            maxDuration: this.MAX_DURATION,
+            leaseInterval: this.LEASE_DURATION,
+            activeLeaseRenewal: this.ACTIVE_LEASE_RENEWAL,
+            frameQuality: 0.3,
+            includeConsole: true,
+            captureAudio: false,
+            ...config
+        };
+    }
+
+    /**
+     * Generate unique session ID
+     */
+    _generateSessionId() {
+        return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    /**
+     * Generate unique owner ID
+     */
+    _generateOwnerId() {
+        return `owner_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    /**
+     * Create standardized error response
+     */
+    _createErrorResponse(type, message, originalError = null) {
+        return {
+            success: false,
+            error: {
+                type,
+                message,
+                timestamp: Date.now(),
+                recoverable: type !== 'STORAGE_ERROR',
+                originalError: originalError?.message
+            }
+        };
+    }
+
+    /**
+     * Debug logging
+     */
+    _logDebug(message, data = {}) {
+        console.log(`[ChromeSessionManager] ${message}`, data);
+    }
+
+    /**
+     * Error logging
+     */
+    _logError(message, error) {
+        console.error(`[ChromeSessionManager] ${message}`, error);
+    }
+
+    /**
+     * Check if session manager is initialized and healthy
+     * @returns {Promise<boolean>} True if initialized and ready
+     */
+    async isInitialized() {
+        try {
+            // Check if we can access storage
+            await this._getRecordingState();
+            return true;
+        } catch (error) {
+            this._logError('isInitialized check failed', error);
+            return false;
+        }
+    }
+
+    /**
+     * Check storage pressure and clean up if needed
+     */
+    async checkStoragePressure() {
+        const usage = await this.getStorageUsage();
+        if (usage > 0.7) { // 70% full
+            console.warn('[ChromeSessionManager] Storage pressure detected, cleaning up old sessions');
+            await this.aggressiveCleanup();
+        }
+    }
+
+    /**
+     * Get storage usage as a ratio (0-1)
+     */
+    async getStorageUsage() {
+        return new Promise(resolve => {
+            chrome.storage.local.getBytesInUse(bytes => {
+                const quota = chrome.storage.local.QUOTA_BYTES || 5242880; // 5MB default
+                resolve(bytes / quota);
+            });
+        });
+    }
+
+    /**
+     * Aggressive cleanup of old sessions when storage pressure is detected
+     */
+    async aggressiveCleanup() {
+        try {
+            const state = await this._getRecordingState();
+            if (state && state.status === 'stopped') {
+                // Remove stopped sessions older than 1 hour during storage pressure
+                const hourAgo = Date.now() - 3600000;
+                if (state.lastActivity < hourAgo) {
+                    await this._removeFromStorage();
+                    console.log('[ChromeSessionManager] Removed old stopped session due to storage pressure');
+                }
+            }
+        } catch (error) {
+            this._logError('Aggressive cleanup failed', error);
+        }
+    }
+
+    /**
+     * Cleanup resources
+     */
+    destroy() {
+        if (this.activeRecordingTimer) {
+            clearInterval(this.activeRecordingTimer);
+            this.activeRecordingTimer = null;
+        }
+    }
+}
+
+// Export for use in other parts of the extension
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = ChromeExtensionSessionManager;
+}