btcp-browser-agent 0.1.9 → 0.1.11

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

@@ -12,7 +12,11 @@ export class SessionManager {
     activeSessionGroupId = null;
     sessionCounter = 0;
     initialized = false;
-    constructor() {
+    maxSession;
+    maxOpenTab;
+    constructor(options = {}) {
+        this.maxSession = options.maxSession ?? 1;
+        this.maxOpenTab = options.maxOpenTab ?? 1;
         // Restore session on creation
         this.restoreSession();
     }
@@ -117,6 +121,13 @@ export class SessionManager {
      */
     async createGroup(options = {}) {
         console.log('[SessionManager] createGroup called with options:', options);
+        // Check if we can create a new session
+        const canCreate = await this.canCreateSession();
+        if (!canCreate) {
+            const count = await this.getSessionCount();
+            throw new Error(`Maximum session limit reached (${count}/${this.maxSession}). ` +
+                `Close an existing session before creating a new one.`);
+        }
         const { tabIds = [], title = this.generateSessionName(), color = 'blue', collapsed = false, } = options;
         // If no tabIds provided, create a new blank tab for the session
         let targetTabIds = tabIds;
@@ -264,14 +275,138 @@ export class SessionManager {
     getActiveSessionGroupId() {
         return this.activeSessionGroupId;
     }
+    /**
+     * Get the maximum number of sessions allowed
+     */
+    getMaxSession() {
+        return this.maxSession;
+    }
+    /**
+     * Get the maximum number of open tabs per session
+     */
+    getMaxOpenTab() {
+        return this.maxOpenTab;
+    }
+    /**
+     * Enforce the tab limit in the active session
+     * Closes oldest tabs if the limit is exceeded
+     */
+    async enforceTabLimit() {
+        if (this.activeSessionGroupId === null) {
+            return;
+        }
+        try {
+            // Get all tabs in the session
+            const tabs = await chrome.tabs.query({ groupId: this.activeSessionGroupId });
+            if (tabs.length <= this.maxOpenTab) {
+                return; // Within limit
+            }
+            // Sort by index (lower index = older tab position)
+            tabs.sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+            // Close excess tabs (oldest first)
+            const tabsToClose = tabs.slice(0, tabs.length - this.maxOpenTab);
+            console.log(`[SessionManager] Closing ${tabsToClose.length} excess tabs to enforce limit of ${this.maxOpenTab}`);
+            for (const tab of tabsToClose) {
+                if (tab.id) {
+                    try {
+                        await chrome.tabs.remove(tab.id);
+                    }
+                    catch (err) {
+                        console.error('[SessionManager] Failed to close tab:', err);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error('[SessionManager] Failed to enforce tab limit:', err);
+        }
+    }
+    /**
+     * Get the count of existing BTCP sessions by checking:
+     * 1. Persistent session from storage
+     * 2. Current active session
+     * 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
+        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;
+                }
+                catch {
+                    // Group no longer exists, clear storage
+                    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'));
+            return btcpGroups.length;
+        }
+        catch (err) {
+            console.error('[SessionManager] Failed to count tab groups:', err);
+            return 0;
+        }
+    }
+    /**
+     * Check if a new session can be created based on maxSession limit
+     */
+    async canCreateSession() {
+        const count = await this.getSessionCount();
+        return count < this.maxSession;
+    }
     /**
      * Set the active session group ID
      */
     setActiveSessionGroupId(groupId) {
         this.activeSessionGroupId = groupId;
     }
+    /**
+     * Use an existing tab group as the active session
+     * This validates the group exists and sets it as active with persistence
+     */
+    async useExistingGroupAsSession(groupId) {
+        try {
+            // Verify the group exists
+            const group = await chrome.tabGroups.get(groupId);
+            console.log('[SessionManager] Using existing group as session:', group);
+            // Set as active session
+            this.activeSessionGroupId = groupId;
+            // Persist to storage
+            await this.persistSession();
+            console.log('[SessionManager] Existing group set as active session');
+            return true;
+        }
+        catch (err) {
+            console.error('[SessionManager] Failed to use existing group as session:', err);
+            return false;
+        }
+    }
     /**
      * Add a tab to the active session (if one exists)
+     * Automatically enforces the tab limit after adding
      */
     async addTabToActiveSession(tabId) {
         if (this.activeSessionGroupId === null) {
@@ -279,6 +414,8 @@ export class SessionManager {
         }
         try {
             await this.addTabsToGroup(this.activeSessionGroupId, [tabId]);
+            // Enforce tab limit after adding
+            await this.enforceTabLimit();
             return true;
         }
         catch (error) {
@@ -311,10 +448,11 @@ export class SessionManager {
 let sessionManagerInstance = null;
 /**
  * Get the singleton SessionManager instance
+ * @param options Options for the SessionManager (only used on first call)
  */
-export function getSessionManager() {
+export function getSessionManager(options) {
     if (!sessionManagerInstance) {
-        sessionManagerInstance = new SessionManager();
+        sessionManagerInstance = new SessionManager(options);
     }
     return sessionManagerInstance;
 }

package/packages/extension/dist/session-types.d.ts

@@ -106,8 +106,15 @@ export interface GroupGetCommand extends ExtensionBaseCommand {
 export interface SessionGetCurrentCommand extends ExtensionBaseCommand {
     action: 'sessionGetCurrent';
 }
+/**
+ * Command to use an existing tab group as the active session
+ */
+export interface SessionUseGroupCommand extends ExtensionBaseCommand {
+    action: 'sessionUseGroup';
+    groupId: number;
+}
 /**
  * Union type of all session-related commands
  */
-export type SessionCommand = GroupCreateCommand | GroupUpdateCommand | GroupDeleteCommand | GroupListCommand | GroupAddTabsCommand | GroupRemoveTabsCommand | GroupGetCommand | SessionGetCurrentCommand;
+export type SessionCommand = GroupCreateCommand | GroupUpdateCommand | GroupDeleteCommand | GroupListCommand | GroupAddTabsCommand | GroupRemoveTabsCommand | GroupGetCommand | SessionGetCurrentCommand | SessionUseGroupCommand;
 //# sourceMappingURL=session-types.d.ts.map

package/packages/extension/dist/types.d.ts

@@ -5,7 +5,7 @@
  */
 import type { Command as CoreCommand, Response } from '../../core/dist/index.js';
 import type { SessionCommand } from './session-types.js';
-export type ExtensionAction = 'navigate' | 'back' | 'forward' | 'reload' | 'getUrl' | 'getTitle' | 'screenshot' | 'tabNew' | 'tabClose' | 'tabSwitch' | 'tabList' | 'groupCreate' | 'groupUpdate' | 'groupDelete' | 'groupList' | 'groupAddTabs' | 'groupRemoveTabs' | 'groupGet' | 'sessionGetCurrent' | 'popupInitialize' | 'scriptInject' | 'scriptSend';
+export type ExtensionAction = 'navigate' | 'back' | 'forward' | 'reload' | 'getUrl' | 'getTitle' | 'screenshot' | 'tabNew' | 'tabClose' | 'tabSwitch' | 'tabList' | 'groupCreate' | 'groupUpdate' | 'groupDelete' | 'groupList' | 'groupAddTabs' | 'groupRemoveTabs' | 'groupGet' | 'sessionGetCurrent' | 'sessionUseGroup' | 'popupInitialize' | 'scriptInject' | 'scriptSend';
 export interface ExtensionBaseCommand {
     /** Optional command ID. Auto-generated if not provided. */
     id?: string;