btcp-browser-agent 0.1.0

package/packages/extension/src/session-manager.ts

@@ -0,0 +1,385 @@
+/**
+ * SessionManager - Manages tab groups and sessions for BTCP Browser Agent
+ */
+
+import type {
+  GroupInfo,
+  SessionInfo,
+  GroupCreateOptions,
+  GroupUpdateOptions,
+  GroupColor,
+} from './session-types.js';
+
+/**
+ * Storage key for session persistence
+ */
+const SESSION_STORAGE_KEY = 'btcp_active_session';
+
+/**
+ * Stored session data
+ */
+interface StoredSessionData {
+  groupId: number;
+  sessionCounter: number;
+  timestamp: number;
+}
+
+/**
+ * SessionManager handles Chrome tab group operations and session state
+ */
+export class SessionManager {
+  private activeSessionGroupId: number | null = null;
+  private sessionCounter = 0;
+  private initialized = false;
+
+  constructor() {
+    // Restore session on creation
+    this.restoreSession();
+  }
+
+  /**
+   * Restore session from storage
+   */
+  private async restoreSession(): Promise<void> {
+    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] as StoredSessionData | undefined;
+
+      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
+   */
+  private async persistSession(): Promise<void> {
+    if (this.activeSessionGroupId === null) {
+      await this.clearStoredSession();
+      return;
+    }
+
+    const data: StoredSessionData = {
+      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
+   */
+  private async clearStoredSession(): Promise<void> {
+    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: number): Promise<boolean> {
+    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] as StoredSessionData | undefined;
+
+      // 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: GroupCreateOptions = {}): Promise<GroupInfo> {
+    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: number, options: GroupUpdateOptions): Promise<GroupInfo> {
+    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: number): Promise<void> {
+    // Get all tabs in the group
+    const tabs = await chrome.tabs.query({ groupId });
+    const tabIds = tabs.map((tab) => tab.id).filter((id): id is number => 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(): Promise<GroupInfo[]> {
+    const groups = await chrome.tabGroups.query({});
+    return groups.map((group) => this.mapChromeGroupToGroupInfo(group));
+  }
+
+  /**
+   * Get a specific tab group
+   */
+  async getGroup(groupId: number): Promise<GroupInfo> {
+    const group = await chrome.tabGroups.get(groupId);
+    return this.mapChromeGroupToGroupInfo(group);
+  }
+
+  /**
+   * Add tabs to a group
+   */
+  async addTabsToGroup(groupId: number, tabIds: number[]): Promise<void> {
+    await chrome.tabs.group({
+      groupId,
+      tabIds,
+    });
+  }
+
+  /**
+   * Remove tabs from their group (ungroup them)
+   */
+  async removeTabsFromGroup(tabIds: number[]): Promise<void> {
+    await chrome.tabs.ungroup(tabIds);
+  }
+
+  /**
+   * Get current active session info
+   */
+  async getCurrentSession(): Promise<SessionInfo | null> {
+    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 is number => id !== undefined);
+
+      return {
+        groupId: this.activeSessionGroupId,
+        title: group.title || 'Untitled Session',
+        color: group.color as GroupColor,
+        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(): number | null {
+    return this.activeSessionGroupId;
+  }
+
+  /**
+   * Set the active session group ID
+   */
+  setActiveSessionGroupId(groupId: number | null): void {
+    this.activeSessionGroupId = groupId;
+  }
+
+  /**
+   * Add a tab to the active session (if one exists)
+   */
+  async addTabToActiveSession(tabId: number): Promise<boolean> {
+    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
+   */
+  private generateSessionName(): string {
+    this.sessionCounter++;
+    return `BTCP Session ${this.sessionCounter}`;
+  }
+
+  /**
+   * Map Chrome tab group to GroupInfo
+   */
+  private mapChromeGroupToGroupInfo(group: chrome.tabGroups.TabGroup): GroupInfo {
+    return {
+      id: group.id,
+      title: group.title,
+      color: group.color as GroupColor,
+      collapsed: group.collapsed,
+      windowId: group.windowId,
+    };
+  }
+}
+
+// Singleton instance
+let sessionManagerInstance: SessionManager | null = null;
+
+/**
+ * Get the singleton SessionManager instance
+ */
+export function getSessionManager(): SessionManager {
+  if (!sessionManagerInstance) {
+    sessionManagerInstance = new SessionManager();
+  }
+  return sessionManagerInstance;
+}

package/packages/extension/src/session-types.ts

@@ -0,0 +1,144 @@
+/**
+ * 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;

package/packages/extension/src/types.ts

@@ -0,0 +1,162 @@
+/**
+ * @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';
+
+// Extension-specific actions
+export type ExtensionAction =
+  | 'navigate'
+  | 'back'
+  | 'forward'
+  | 'reload'
+  | 'getUrl'
+  | 'getTitle'
+  | 'screenshot'
+  | 'tabNew'
+  | 'tabClose'
+  | 'tabSwitch'
+  | 'tabList'
+  | 'groupCreate'
+  | 'groupUpdate'
+  | 'groupDelete'
+  | 'groupList'
+  | 'groupAddTabs'
+  | 'groupRemoveTabs'
+  | 'groupGet'
+  | 'sessionGetCurrent'
+  | 'popupInitialize';
+
+// Base extension command
+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';
+}
+
+// Union of extension commands
+export type ExtensionCommand =
+  | NavigateCommand
+  | BackCommand
+  | ForwardCommand
+  | ReloadCommand
+  | GetUrlCommand
+  | GetTitleCommand
+  | ScreenshotCommand
+  | TabNewCommand
+  | TabCloseCommand
+  | TabSwitchCommand
+  | TabListCommand
+  | PopupInitializeCommand
+  | SessionCommand;
+
+// Combined command type (core + extension)
+export type Command = CoreCommand | ExtensionCommand;
+
+// Re-export Response type
+export type { Response };
+
+// Re-export session types
+export type {
+  SessionCommand,
+  GroupInfo,
+  SessionInfo,
+  GroupCreateOptions,
+  GroupUpdateOptions,
+} from './session-types.js';
+
+// Message types for extension communication
+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;
+
+// Tab info
+export interface TabInfo {
+  id: number;
+  url?: string;
+  title?: string;
+  active: boolean;
+  index: number;
+}
+
+// Chrome tab type alias (uses @types/chrome)
+export type ChromeTab = chrome.tabs.Tab;

package/packages/extension/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022", "DOM", "DOM.Iterable", "WebWorker"],
+    "types": ["chrome"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "baseUrl": ".",
+    "paths": {
+      "@btcp/core": ["../core/dist/index.d.ts"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}