btcp-browser-agent 0.1.0 → 0.1.1

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

@@ -0,0 +1,322 @@
+/**
+ * SessionManager - Manages tab groups and sessions for BTCP Browser Agent
+ */
+/**
+ * Storage key for session persistence
+ */
+const SESSION_STORAGE_KEY = 'btcp_active_session';
+/**
+ * SessionManager handles Chrome tab group operations and session state
+ */
+export class SessionManager {
+    activeSessionGroupId = null;
+    sessionCounter = 0;
+    initialized = false;
+    constructor() {
+        // Restore session on creation
+        this.restoreSession();
+    }
+    /**
+     * Restore session from storage
+     */
+    async restoreSession() {
+        if (this.initialized)
+            return;
+        try {
+            console.log('[SessionManager] Restoring session from storage...');
+            const result = await chrome.storage.session.get(SESSION_STORAGE_KEY);
+            const data = result[SESSION_STORAGE_KEY];
+            if (data?.groupId) {
+                console.log('[SessionManager] Found stored session:', data);
+                // Verify the group still exists
+                try {
+                    const group = await chrome.tabGroups.get(data.groupId);
+                    console.log('[SessionManager] Group still exists:', group);
+                    // Restore session state
+                    this.activeSessionGroupId = data.groupId;
+                    this.sessionCounter = data.sessionCounter;
+                    console.log('[SessionManager] Session restored successfully');
+                }
+                catch (err) {
+                    console.log('[SessionManager] Stored group no longer exists, clearing...');
+                    await this.clearStoredSession();
+                }
+            }
+            else {
+                console.log('[SessionManager] No stored session found');
+            }
+        }
+        catch (err) {
+            console.error('[SessionManager] Failed to restore session:', err);
+        }
+        finally {
+            this.initialized = true;
+        }
+    }
+    /**
+     * Persist session to storage
+     */
+    async persistSession() {
+        if (this.activeSessionGroupId === null) {
+            await this.clearStoredSession();
+            return;
+        }
+        const data = {
+            groupId: this.activeSessionGroupId,
+            sessionCounter: this.sessionCounter,
+            timestamp: Date.now(),
+        };
+        try {
+            await chrome.storage.session.set({ [SESSION_STORAGE_KEY]: data });
+            console.log('[SessionManager] Session persisted:', data);
+        }
+        catch (err) {
+            console.error('[SessionManager] Failed to persist session:', err);
+        }
+    }
+    /**
+     * Clear stored session
+     */
+    async clearStoredSession() {
+        try {
+            await chrome.storage.session.remove(SESSION_STORAGE_KEY);
+            console.log('[SessionManager] Cleared stored session');
+        }
+        catch (err) {
+            console.error('[SessionManager] Failed to clear stored session:', err);
+        }
+    }
+    /**
+     * Reconnect to a specific session group
+     * Used when popup detects a stored session that isn't currently active
+     */
+    async reconnectSession(groupId) {
+        try {
+            console.log('[SessionManager] Attempting to reconnect to session group:', groupId);
+            // Verify the group still exists
+            const group = await chrome.tabGroups.get(groupId);
+            console.log('[SessionManager] Group found:', group);
+            // Get stored session data for counter
+            const result = await chrome.storage.session.get(SESSION_STORAGE_KEY);
+            const data = result[SESSION_STORAGE_KEY];
+            // Restore session state
+            this.activeSessionGroupId = groupId;
+            this.sessionCounter = data?.sessionCounter ?? this.sessionCounter;
+            console.log('[SessionManager] Session reconnected successfully');
+            return true;
+        }
+        catch (err) {
+            console.error('[SessionManager] Failed to reconnect session:', err);
+            // Clear invalid stored session
+            await this.clearStoredSession();
+            return false;
+        }
+    }
+    /**
+     * Create a new tab group
+     */
+    async createGroup(options = {}) {
+        console.log('[SessionManager] createGroup called with options:', options);
+        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;
+        if (targetTabIds.length === 0) {
+            console.log('[SessionManager] No tabIds provided, creating new blank tab...');
+            const newTab = await chrome.tabs.create({
+                url: 'about:blank',
+                active: true
+            });
+            console.log('[SessionManager] Created new tab:', newTab.id);
+            if (newTab?.id) {
+                targetTabIds = [newTab.id];
+            }
+            else {
+                console.error('[SessionManager] Failed to create new tab');
+                throw new Error('Failed to create new tab for session');
+            }
+        }
+        console.log('[SessionManager] Creating group with tabs:', targetTabIds);
+        // Get the window for the tab (must be a normal window)
+        const tabs = await chrome.tabs.query({ windowId: chrome.windows.WINDOW_ID_CURRENT });
+        const targetTab = tabs.find(t => targetTabIds.includes(t.id));
+        if (!targetTab || !targetTab.windowId) {
+            console.error('[SessionManager] Could not find valid window for tab');
+            throw new Error('Could not find a normal window for the tab');
+        }
+        // Verify it's a normal window, not popup/devtools/etc
+        const window = await chrome.windows.get(targetTab.windowId);
+        if (window.type !== 'normal') {
+            console.error('[SessionManager] Window is not normal type:', window.type);
+            throw new Error(`Tabs can only be grouped in normal windows, not ${window.type} windows`);
+        }
+        // Create the group
+        const groupId = await chrome.tabs.group({
+            tabIds: targetTabIds,
+            createProperties: {
+                windowId: targetTab.windowId,
+            },
+        });
+        console.log('[SessionManager] Group created with ID:', groupId);
+        // Update group properties
+        await chrome.tabGroups.update(groupId, {
+            title,
+            color,
+            collapsed,
+        });
+        console.log('[SessionManager] Group updated with title:', title);
+        // Set as active session
+        this.activeSessionGroupId = groupId;
+        // Persist to storage
+        await this.persistSession();
+        // Get group info
+        const group = await chrome.tabGroups.get(groupId);
+        console.log('[SessionManager] Group info:', group);
+        return this.mapChromeGroupToGroupInfo(group);
+    }
+    /**
+     * Update an existing tab group
+     */
+    async updateGroup(groupId, options) {
+        await chrome.tabGroups.update(groupId, {
+            ...(options.title !== undefined && { title: options.title }),
+            ...(options.color !== undefined && { color: options.color }),
+            ...(options.collapsed !== undefined && { collapsed: options.collapsed }),
+        });
+        const group = await chrome.tabGroups.get(groupId);
+        return this.mapChromeGroupToGroupInfo(group);
+    }
+    /**
+     * Delete a tab group (closes all tabs in the group)
+     */
+    async deleteGroup(groupId) {
+        // Get all tabs in the group
+        const tabs = await chrome.tabs.query({ groupId });
+        const tabIds = tabs.map((tab) => tab.id).filter((id) => id !== undefined);
+        // Close all tabs (this automatically removes the group)
+        if (tabIds.length > 0) {
+            await chrome.tabs.remove(tabIds);
+        }
+        // Clear active session if this was the active group
+        if (this.activeSessionGroupId === groupId) {
+            this.activeSessionGroupId = null;
+            // Clear from storage
+            await this.clearStoredSession();
+        }
+    }
+    /**
+     * List all tab groups
+     */
+    async listGroups() {
+        const groups = await chrome.tabGroups.query({});
+        return groups.map((group) => this.mapChromeGroupToGroupInfo(group));
+    }
+    /**
+     * Get a specific tab group
+     */
+    async getGroup(groupId) {
+        const group = await chrome.tabGroups.get(groupId);
+        return this.mapChromeGroupToGroupInfo(group);
+    }
+    /**
+     * Add tabs to a group
+     */
+    async addTabsToGroup(groupId, tabIds) {
+        await chrome.tabs.group({
+            groupId,
+            tabIds,
+        });
+    }
+    /**
+     * Remove tabs from their group (ungroup them)
+     */
+    async removeTabsFromGroup(tabIds) {
+        await chrome.tabs.ungroup(tabIds);
+    }
+    /**
+     * Get current active session info
+     */
+    async getCurrentSession() {
+        if (this.activeSessionGroupId === null) {
+            return null;
+        }
+        try {
+            const group = await chrome.tabGroups.get(this.activeSessionGroupId);
+            const tabs = await chrome.tabs.query({ groupId: this.activeSessionGroupId });
+            const tabIds = tabs.map((tab) => tab.id).filter((id) => id !== undefined);
+            return {
+                groupId: this.activeSessionGroupId,
+                title: group.title || 'Untitled Session',
+                color: group.color,
+                tabCount: tabs.length,
+                tabIds,
+                windowId: group.windowId,
+                createdAt: Date.now(),
+            };
+        }
+        catch (error) {
+            // Group no longer exists
+            this.activeSessionGroupId = null;
+            return null;
+        }
+    }
+    /**
+     * Get the active session group ID
+     */
+    getActiveSessionGroupId() {
+        return this.activeSessionGroupId;
+    }
+    /**
+     * Set the active session group ID
+     */
+    setActiveSessionGroupId(groupId) {
+        this.activeSessionGroupId = groupId;
+    }
+    /**
+     * Add a tab to the active session (if one exists)
+     */
+    async addTabToActiveSession(tabId) {
+        if (this.activeSessionGroupId === null) {
+            return false;
+        }
+        try {
+            await this.addTabsToGroup(this.activeSessionGroupId, [tabId]);
+            return true;
+        }
+        catch (error) {
+            // Group may no longer exist
+            this.activeSessionGroupId = null;
+            return false;
+        }
+    }
+    /**
+     * Generate a session name
+     */
+    generateSessionName() {
+        this.sessionCounter++;
+        return `BTCP Session ${this.sessionCounter}`;
+    }
+    /**
+     * Map Chrome tab group to GroupInfo
+     */
+    mapChromeGroupToGroupInfo(group) {
+        return {
+            id: group.id,
+            title: group.title,
+            color: group.color,
+            collapsed: group.collapsed,
+            windowId: group.windowId,
+        };
+    }
+}
+// Singleton instance
+let sessionManagerInstance = null;
+/**
+ * Get the singleton SessionManager instance
+ */
+export function getSessionManager() {
+    if (!sessionManagerInstance) {
+        sessionManagerInstance = new SessionManager();
+    }
+    return sessionManagerInstance;
+}
+//# sourceMappingURL=session-manager.js.map

package/packages/extension/{src/session-types.ts → dist/session-types.d.ts}

@@ -1,144 +1,113 @@
-/**
- * Session and Tab Group types for BTCP Browser Agent
- */
-
-import type { ExtensionBaseCommand } from './types.js';
-
-/**
- * Chrome tab group color options
- */
-export type GroupColor =
-  | 'grey'
-  | 'blue'
-  | 'red'
-  | 'yellow'
-  | 'green'
-  | 'pink'
-  | 'purple'
-  | 'cyan'
-  | 'orange';
-
-/**
- * Tab group information
- */
-export interface GroupInfo {
-  id: number;
-  title?: string;
-  color: GroupColor;
-  collapsed: boolean;
-  windowId: number;
-}
-
-/**
- * Session information
- */
-export interface SessionInfo {
-  groupId: number;
-  title: string;
-  color: GroupColor;
-  tabCount: number;
-  tabIds: number[];
-  windowId: number;
-  createdAt: number;
-}
-
-/**
- * Options for creating a new tab group
- */
-export interface GroupCreateOptions {
-  tabIds?: number[];
-  title?: string;
-  color?: GroupColor;
-  collapsed?: boolean;
-}
-
-/**
- * Options for updating a tab group
- */
-export interface GroupUpdateOptions {
-  title?: string;
-  color?: GroupColor;
-  collapsed?: boolean;
-}
-
-/**
- * Command to create a new tab group
- */
-export interface GroupCreateCommand extends ExtensionBaseCommand {
-  action: 'groupCreate';
-  tabIds?: number[];
-  title?: string;
-  color?: GroupColor;
-  collapsed?: boolean;
-}
-
-/**
- * Command to update a tab group
- */
-export interface GroupUpdateCommand extends ExtensionBaseCommand {
-  action: 'groupUpdate';
-  groupId: number;
-  title?: string;
-  color?: GroupColor;
-  collapsed?: boolean;
-}
-
-/**
- * Command to delete a tab group (closes all tabs)
- */
-export interface GroupDeleteCommand extends ExtensionBaseCommand {
-  action: 'groupDelete';
-  groupId: number;
-}
-
-/**
- * Command to list all tab groups
- */
-export interface GroupListCommand extends ExtensionBaseCommand {
-  action: 'groupList';
-}
-
-/**
- * Command to add tabs to a group
- */
-export interface GroupAddTabsCommand extends ExtensionBaseCommand {
-  action: 'groupAddTabs';
-  groupId: number;
-  tabIds: number[];
-}
-
-/**
- * Command to remove tabs from a group
- */
-export interface GroupRemoveTabsCommand extends ExtensionBaseCommand {
-  action: 'groupRemoveTabs';
-  tabIds: number[];
-}
-
-/**
- * Command to get a specific tab group
- */
-export interface GroupGetCommand extends ExtensionBaseCommand {
-  action: 'groupGet';
-  groupId: number;
-}
-
-/**
- * Command to get current active session
- */
-export interface SessionGetCurrentCommand extends ExtensionBaseCommand {
-  action: 'sessionGetCurrent';
-}
-
-/**
- * Union type of all session-related commands
- */
-export type SessionCommand =
-  | GroupCreateCommand
-  | GroupUpdateCommand
-  | GroupDeleteCommand
-  | GroupListCommand
-  | GroupAddTabsCommand
-  | GroupRemoveTabsCommand
-  | GroupGetCommand
-  | SessionGetCurrentCommand;
+/**
+ * Session and Tab Group types for BTCP Browser Agent
+ */
+import type { ExtensionBaseCommand } from './types.js';
+/**
+ * Chrome tab group color options
+ */
+export type GroupColor = 'grey' | 'blue' | 'red' | 'yellow' | 'green' | 'pink' | 'purple' | 'cyan' | 'orange';
+/**
+ * Tab group information
+ */
+export interface GroupInfo {
+    id: number;
+    title?: string;
+    color: GroupColor;
+    collapsed: boolean;
+    windowId: number;
+}
+/**
+ * Session information
+ */
+export interface SessionInfo {
+    groupId: number;
+    title: string;
+    color: GroupColor;
+    tabCount: number;
+    tabIds: number[];
+    windowId: number;
+    createdAt: number;
+}
+/**
+ * Options for creating a new tab group
+ */
+export interface GroupCreateOptions {
+    tabIds?: number[];
+    title?: string;
+    color?: GroupColor;
+    collapsed?: boolean;
+}
+/**
+ * Options for updating a tab group
+ */
+export interface GroupUpdateOptions {
+    title?: string;
+    color?: GroupColor;
+    collapsed?: boolean;
+}
+/**
+ * Command to create a new tab group
+ */
+export interface GroupCreateCommand extends ExtensionBaseCommand {
+    action: 'groupCreate';
+    tabIds?: number[];
+    title?: string;
+    color?: GroupColor;
+    collapsed?: boolean;
+}
+/**
+ * Command to update a tab group
+ */
+export interface GroupUpdateCommand extends ExtensionBaseCommand {
+    action: 'groupUpdate';
+    groupId: number;
+    title?: string;
+    color?: GroupColor;
+    collapsed?: boolean;
+}
+/**
+ * Command to delete a tab group (closes all tabs)
+ */
+export interface GroupDeleteCommand extends ExtensionBaseCommand {
+    action: 'groupDelete';
+    groupId: number;
+}
+/**
+ * Command to list all tab groups
+ */
+export interface GroupListCommand extends ExtensionBaseCommand {
+    action: 'groupList';
+}
+/**
+ * Command to add tabs to a group
+ */
+export interface GroupAddTabsCommand extends ExtensionBaseCommand {
+    action: 'groupAddTabs';
+    groupId: number;
+    tabIds: number[];
+}
+/**
+ * Command to remove tabs from a group
+ */
+export interface GroupRemoveTabsCommand extends ExtensionBaseCommand {
+    action: 'groupRemoveTabs';
+    tabIds: number[];
+}
+/**
+ * Command to get a specific tab group
+ */
+export interface GroupGetCommand extends ExtensionBaseCommand {
+    action: 'groupGet';
+    groupId: number;
+}
+/**
+ * Command to get current active session
+ */
+export interface SessionGetCurrentCommand extends ExtensionBaseCommand {
+    action: 'sessionGetCurrent';
+}
+/**
+ * Union type of all session-related commands
+ */
+export type SessionCommand = GroupCreateCommand | GroupUpdateCommand | GroupDeleteCommand | GroupListCommand | GroupAddTabsCommand | GroupRemoveTabsCommand | GroupGetCommand | SessionGetCurrentCommand;
+//# sourceMappingURL=session-types.d.ts.map

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

@@ -0,0 +1,5 @@
+/**
+ * Session and Tab Group types for BTCP Browser Agent
+ */
+export {};
+//# sourceMappingURL=session-types.js.map

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

@@ -0,0 +1,88 @@
+/**
+ * @btcp/extension - Type definitions
+ *
+ * Types for extension commands and Chrome API wrappers.
+ */
+import type { Command as CoreCommand, Response } from '@btcp/core';
+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';
+export interface ExtensionBaseCommand {
+    id: string;
+    action: ExtensionAction;
+}
+export interface NavigateCommand extends ExtensionBaseCommand {
+    action: 'navigate';
+    url: string;
+    waitUntil?: 'load' | 'domcontentloaded';
+}
+export interface BackCommand extends ExtensionBaseCommand {
+    action: 'back';
+}
+export interface ForwardCommand extends ExtensionBaseCommand {
+    action: 'forward';
+}
+export interface ReloadCommand extends ExtensionBaseCommand {
+    action: 'reload';
+    bypassCache?: boolean;
+}
+export interface GetUrlCommand extends ExtensionBaseCommand {
+    action: 'getUrl';
+}
+export interface GetTitleCommand extends ExtensionBaseCommand {
+    action: 'getTitle';
+}
+export interface ScreenshotCommand extends ExtensionBaseCommand {
+    action: 'screenshot';
+    format?: 'png' | 'jpeg';
+    quality?: number;
+}
+export interface TabNewCommand extends ExtensionBaseCommand {
+    action: 'tabNew';
+    url?: string;
+    active?: boolean;
+}
+export interface TabCloseCommand extends ExtensionBaseCommand {
+    action: 'tabClose';
+    tabId?: number;
+}
+export interface TabSwitchCommand extends ExtensionBaseCommand {
+    action: 'tabSwitch';
+    tabId: number;
+}
+export interface TabListCommand extends ExtensionBaseCommand {
+    action: 'tabList';
+}
+export interface PopupInitializeCommand extends ExtensionBaseCommand {
+    action: 'popupInitialize';
+}
+export type ExtensionCommand = NavigateCommand | BackCommand | ForwardCommand | ReloadCommand | GetUrlCommand | GetTitleCommand | ScreenshotCommand | TabNewCommand | TabCloseCommand | TabSwitchCommand | TabListCommand | PopupInitializeCommand | SessionCommand;
+export type Command = CoreCommand | ExtensionCommand;
+export type { Response };
+export type { SessionCommand, GroupInfo, SessionInfo, GroupCreateOptions, GroupUpdateOptions, } from './session-types.js';
+export interface ExtensionCommandMessage {
+    type: 'btcp:command';
+    command: Command;
+    tabId?: number;
+}
+export interface ExtensionPingMessage {
+    type: 'btcp:ping';
+}
+export type ExtensionMessage = ExtensionCommandMessage | ExtensionPingMessage;
+export interface ExtensionResponseMessage {
+    type: 'btcp:response';
+    response: Response;
+}
+export interface ExtensionPongResponse {
+    type: 'btcp:pong';
+    ready: boolean;
+}
+export type ExtensionResponse = ExtensionResponseMessage | ExtensionPongResponse;
+export interface TabInfo {
+    id: number;
+    url?: string;
+    title?: string;
+    active: boolean;
+    index: number;
+}
+export type ChromeTab = chrome.tabs.Tab;
+//# sourceMappingURL=types.d.ts.map

package/packages/extension/dist/types.js

@@ -0,0 +1,7 @@
+/**
+ * @btcp/extension - Type definitions
+ *
+ * Types for extension commands and Chrome API wrappers.
+ */
+export {};
+//# sourceMappingURL=types.js.map