btcp-browser-agent 0.1.12 → 0.1.14

package/packages/extension/dist/session-manager.js

@@ -12,13 +12,20 @@ export class SessionManager {
     activeSessionGroupId = null;
     sessionCounter = 0;
     initialized = false;
+    initializationPromise;
     maxSession;
     maxOpenTab;
     constructor(options = {}) {
         this.maxSession = options.maxSession ?? 1;
         this.maxOpenTab = options.maxOpenTab ?? 1;
-        // Restore session on creation
-        this.restoreSession();
+        // Restore session on creation and store the promise
+        this.initializationPromise = this.restoreSession();
+    }
+    /**
+     * Wait for SessionManager to finish initialization
+     */
+    async waitForInitialization() {
+        await this.initializationPromise;
     }
     /**
      * Restore session from storage
@@ -49,6 +56,8 @@ export class SessionManager {
             else {
                 console.log('[SessionManager] No stored session found');
             }
+            // Clean up any duplicate sessions after restoring
+            await this.cleanupDuplicateSessions();
         }
         catch (err) {
             console.error('[SessionManager] Failed to restore session:', err);
@@ -57,6 +66,98 @@ export class SessionManager {
             this.initialized = true;
         }
     }
+    /**
+     * Scan for and cleanup duplicate BTCP session groups
+     * Ensures only one BTCP session exists at any time
+     *
+     * @returns Stats about cleanup: { found, kept, removed }
+     */
+    async cleanupDuplicateSessions() {
+        try {
+            console.log('[SessionManager] Scanning for duplicate BTCP sessions...');
+            // Get all tab groups
+            const allGroups = await chrome.tabGroups.query({});
+            const btcpGroups = allGroups.filter(g => g.title?.startsWith('BTCP'));
+            console.log(`[SessionManager] Found ${btcpGroups.length} BTCP session group(s)`);
+            if (btcpGroups.length <= 1) {
+                // No duplicates, nothing to clean up
+                return { found: btcpGroups.length, kept: btcpGroups.length, removed: 0 };
+            }
+            // Multiple sessions found - need to consolidate
+            console.warn(`[SessionManager] Found ${btcpGroups.length} BTCP sessions - cleaning up duplicates!`);
+            // Determine which session to keep
+            let toKeep;
+            // Priority 1: Keep the one matching stored session ID
+            if (this.activeSessionGroupId !== null) {
+                const activeGroup = btcpGroups.find(g => g.id === this.activeSessionGroupId);
+                if (activeGroup) {
+                    console.log('[SessionManager] Keeping active session:', activeGroup.id);
+                    toKeep = activeGroup;
+                }
+            }
+            // Priority 2: Keep the one from storage if active session not set
+            if (!toKeep) {
+                const result = await chrome.storage.session.get(SESSION_STORAGE_KEY);
+                const data = result[SESSION_STORAGE_KEY];
+                if (data?.groupId) {
+                    const storedGroup = btcpGroups.find(g => g.id === data.groupId);
+                    if (storedGroup) {
+                        console.log('[SessionManager] Keeping stored session:', storedGroup.id);
+                        toKeep = storedGroup;
+                    }
+                }
+            }
+            // Priority 3: Keep the one with the most tabs
+            if (!toKeep) {
+                console.log('[SessionManager] No active/stored session - keeping the one with most tabs');
+                const groupsWithTabCounts = await Promise.all(btcpGroups.map(async (g) => ({
+                    group: g,
+                    tabs: await chrome.tabs.query({ groupId: g.id })
+                })));
+                groupsWithTabCounts.sort((a, b) => b.tabs.length - a.tabs.length);
+                toKeep = groupsWithTabCounts[0]?.group;
+                if (toKeep) {
+                    console.log(`[SessionManager] Keeping session ${toKeep.id} with ${groupsWithTabCounts[0].tabs.length} tabs`);
+                }
+            }
+            // If we still don't have a group to keep (shouldn't happen), just keep the first one
+            if (!toKeep) {
+                toKeep = btcpGroups[0];
+                console.log('[SessionManager] Fallback: keeping first session:', toKeep.id);
+            }
+            // Delete all other sessions
+            const toDelete = btcpGroups.filter(g => g.id !== toKeep.id);
+            console.log(`[SessionManager] Removing ${toDelete.length} duplicate session(s)`);
+            for (const group of toDelete) {
+                try {
+                    console.log(`[SessionManager] Deleting duplicate session: ${group.id} (${group.title})`);
+                    // Get tabs in this group and ungroup them (don't close them)
+                    const tabs = await chrome.tabs.query({ groupId: group.id });
+                    for (const tab of tabs) {
+                        if (tab.id !== undefined) {
+                            await chrome.tabs.ungroup(tab.id);
+                        }
+                    }
+                }
+                catch (err) {
+                    console.error(`[SessionManager] Failed to delete duplicate session ${group.id}:`, err);
+                }
+            }
+            // Set the kept session as active
+            this.activeSessionGroupId = toKeep.id;
+            await this.persistSession();
+            console.log('[SessionManager] Cleanup complete - only one session remains');
+            return {
+                found: btcpGroups.length,
+                kept: 1,
+                removed: toDelete.length
+            };
+        }
+        catch (err) {
+            console.error('[SessionManager] Failed to cleanup duplicate sessions:', err);
+            return { found: 0, kept: 0, removed: 0 };
+        }
+    }
     /**
      * Persist session to storage
      */
@@ -95,6 +196,7 @@ export class SessionManager {
      * Used when popup detects a stored session that isn't currently active
      */
     async reconnectSession(groupId) {
+        await this.waitForInitialization();
         try {
             console.log('[SessionManager] Attempting to reconnect to session group:', groupId);
             // Verify the group still exists
@@ -106,6 +208,8 @@ export class SessionManager {
             // Restore session state
             this.activeSessionGroupId = groupId;
             this.sessionCounter = data?.sessionCounter ?? this.sessionCounter;
+            // Persist session state after reconnecting
+            await this.persistSession();
             console.log('[SessionManager] Session reconnected successfully');
             return true;
         }
@@ -120,6 +224,8 @@ export class SessionManager {
      * Create a new tab group
      */
     async createGroup(options = {}) {
+        // Wait for initialization to complete first
+        await this.waitForInitialization();
         console.log('[SessionManager] createGroup called with options:', options);
         // Check if we can create a new session
         const canCreate = await this.canCreateSession();
@@ -246,6 +352,7 @@ export class SessionManager {
      * Get current active session info
      */
     async getCurrentSession() {
+        await this.waitForInitialization();
         if (this.activeSessionGroupId === null) {
             return null;
         }
@@ -275,6 +382,13 @@ export class SessionManager {
     getActiveSessionGroupId() {
         return this.activeSessionGroupId;
     }
+    /**
+     * Get the active session group ID (async version that ensures initialization is complete)
+     */
+    async getActiveSessionGroupIdAsync() {
+        await this.waitForInitialization();
+        return this.activeSessionGroupId;
+    }
     /**
      * Get the maximum number of sessions allowed
      */
@@ -292,6 +406,7 @@ export class SessionManager {
      * Closes oldest tabs if the limit is exceeded
      */
     async enforceTabLimit() {
+        await this.waitForInitialization();
         if (this.activeSessionGroupId === null) {
             return;
         }
@@ -328,41 +443,31 @@ export class SessionManager {
      * 3. Existing tab groups (BTCP prefixed)
      */
     async getSessionCount() {
-        // If we have an active session, that counts as 1
-        if (this.activeSessionGroupId !== null) {
-            try {
-                // Verify the group still exists
-                await chrome.tabGroups.get(this.activeSessionGroupId);
-                return 1;
-            }
-            catch {
-                // Group no longer exists, clear it
-                this.activeSessionGroupId = null;
-            }
-        }
-        // Check if there's a persistent session in storage
+        // Always count all BTCP tab groups to detect duplicates
         try {
-            const result = await chrome.storage.session.get(SESSION_STORAGE_KEY);
-            const data = result[SESSION_STORAGE_KEY];
-            if (data?.groupId) {
-                // Verify the stored group still exists
-                try {
-                    await chrome.tabGroups.get(data.groupId);
-                    return 1;
+            const groups = await chrome.tabGroups.query({});
+            const btcpGroups = groups.filter(g => g.title?.startsWith('BTCP'));
+            // Clean up stale references while counting
+            if (this.activeSessionGroupId !== null) {
+                const activeExists = btcpGroups.some(g => g.id === this.activeSessionGroupId);
+                if (!activeExists) {
+                    this.activeSessionGroupId = null;
                 }
-                catch {
-                    // Group no longer exists, clear storage
-                    await this.clearStoredSession();
+            }
+            // Check stored session exists
+            try {
+                const result = await chrome.storage.session.get(SESSION_STORAGE_KEY);
+                const data = result[SESSION_STORAGE_KEY];
+                if (data?.groupId) {
+                    const storedExists = btcpGroups.some(g => g.id === data.groupId);
+                    if (!storedExists) {
+                        await this.clearStoredSession();
+                    }
                 }
             }
-        }
-        catch (err) {
-            console.error('[SessionManager] Failed to check persistent session:', err);
-        }
-        // Count existing BTCP tab groups
-        try {
-            const groups = await chrome.tabGroups.query({});
-            const btcpGroups = groups.filter(g => g.title?.startsWith('BTCP'));
+            catch (err) {
+                console.error('[SessionManager] Failed to check persistent session:', err);
+            }
             return btcpGroups.length;
         }
         catch (err) {
@@ -404,11 +509,65 @@ export class SessionManager {
             return false;
         }
     }
+    /**
+     * Ensure a session exists - restore from storage, use existing, or create new
+     * Returns the session group ID (creates if needed)
+     */
+    async ensureSession() {
+        await this.waitForInitialization();
+        // Step 1: Already have active session
+        if (this.activeSessionGroupId !== null) {
+            // Verify it still exists
+            try {
+                await chrome.tabGroups.get(this.activeSessionGroupId);
+                return this.activeSessionGroupId;
+            }
+            catch {
+                // Group no longer exists, continue to restore/create
+                this.activeSessionGroupId = null;
+            }
+        }
+        // Step 2: Try to restore from storage
+        const result = await chrome.storage.session.get(SESSION_STORAGE_KEY);
+        const stored = result[SESSION_STORAGE_KEY];
+        if (stored?.groupId) {
+            const reconnected = await this.reconnectSession(stored.groupId);
+            if (reconnected && this.activeSessionGroupId !== null) {
+                return this.activeSessionGroupId;
+            }
+        }
+        // Step 3: Find existing BTCP group
+        const groups = await chrome.tabGroups.query({});
+        const btcpGroup = groups.find(g => g.title?.startsWith('BTCP'));
+        if (btcpGroup) {
+            const used = await this.useExistingGroupAsSession(btcpGroup.id);
+            if (used && this.activeSessionGroupId !== null) {
+                return this.activeSessionGroupId;
+            }
+        }
+        // Step 4: Create new session
+        console.log('[SessionManager] No existing session found, creating new one...');
+        const newGroup = await this.createGroup({ color: 'blue' });
+        return newGroup.id;
+    }
+    /**
+     * Get the primary tab in session (ensures session exists first)
+     * Returns the first tab in the session group
+     */
+    async getSessionTab() {
+        const groupId = await this.ensureSession();
+        const tabs = await chrome.tabs.query({ groupId });
+        if (tabs.length === 0 || tabs[0].id === undefined) {
+            throw new Error('Session exists but has no tabs');
+        }
+        return tabs[0].id;
+    }
     /**
      * Add a tab to the active session (if one exists)
      * Automatically enforces the tab limit after adding
      */
     async addTabToActiveSession(tabId) {
+        await this.waitForInitialization();
         if (this.activeSessionGroupId === null) {
             return false;
         }