btcp-browser-agent 0.1.0 → 0.1.2

package/packages/extension/dist/index.js

@@ -0,0 +1,350 @@
+/**
+ * @btcp/extension
+ *
+ * Chrome extension bridge for browser automation.
+ *
+ * Architecture:
+ * - BackgroundAgent: Runs in background script, manages tabs/navigation/screenshots
+ * - ContentAgent: Runs in content scripts, handles DOM operations (from @btcp/core)
+ * - Client: API for sending commands from popup or external scripts
+ *
+ * @example Background script setup:
+ * ```typescript
+ * import { BackgroundAgent, setupMessageListener } from '@btcp/extension';
+ *
+ * // Set up message routing
+ * setupMessageListener();
+ *
+ * // Or use BackgroundAgent directly
+ * const agent = new BackgroundAgent();
+ * await agent.navigate('https://example.com');
+ * await agent.screenshot();
+ * ```
+ *
+ * @example Content script setup:
+ * ```typescript
+ * import { createContentAgent } from '@btcp/core';
+ *
+ * const agent = createContentAgent();
+ * await agent.execute({ id: '1', action: 'snapshot' });
+ * ```
+ *
+ * @example Popup/external usage:
+ * ```typescript
+ * import { createClient } from '@btcp/extension';
+ *
+ * const client = createClient();
+ * await client.navigate('https://example.com');
+ * const snapshot = await client.snapshot();
+ * await client.click('@ref:5');
+ * ```
+ */
+// Import for local use (and re-export below)
+import { BackgroundAgent as _BackgroundAgent, getBackgroundAgent as _getBackgroundAgent, setupMessageListener as _setupMessageListener, BrowserAgent as _BrowserAgent, getBrowserAgent as _getBrowserAgent, } from './background.js';
+export * from './types.js';
+// Re-export BackgroundAgent for background script usage
+export { _BackgroundAgent as BackgroundAgent, _getBackgroundAgent as getBackgroundAgent, _setupMessageListener as setupMessageListener, 
+// Deprecated aliases for backwards compatibility
+_BrowserAgent as BrowserAgent, _getBrowserAgent as getBrowserAgent, };
+// Re-export ContentAgent for content script usage
+export { createContentAgent } from '../../core/dist/index.js';
+let commandIdCounter = 0;
+function generateCommandId() {
+    return `cmd_${Date.now()}_${commandIdCounter++}`;
+}
+/**
+ * Check if we're running in a background/service worker context
+ */
+function isBackgroundContext() {
+    // In Manifest V3, background scripts run as service workers
+    return typeof ServiceWorkerGlobalScope !== 'undefined' && self instanceof ServiceWorkerGlobalScope;
+}
+/**
+ * Create a client for communicating with the extension
+ *
+ * This function works in both popup/content scripts and background scripts:
+ * - In popup/content scripts: Uses chrome.runtime.sendMessage to communicate with background
+ * - In background scripts: Uses BackgroundAgent directly for better performance
+ *
+ * @example Popup usage:
+ * ```typescript
+ * import { createClient } from '@btcp/browser-agent/extension';
+ * const client = createClient();
+ * await client.navigate('https://example.com');
+ * ```
+ *
+ * @example Background script usage:
+ * ```typescript
+ * import { createClient } from '@btcp/browser-agent/extension';
+ * const client = createClient();
+ * // Works the same way - commands go directly to BackgroundAgent
+ * await client.navigate('https://example.com');
+ * ```
+ */
+export function createClient() {
+    // Detect if we're in background context
+    const inBackground = isBackgroundContext();
+    // Lazily get the background agent to avoid circular dependency issues
+    let bgAgent = null;
+    function getAgent() {
+        if (!bgAgent) {
+            // Use the singleton getter from background.js
+            bgAgent = _getBackgroundAgent();
+        }
+        return bgAgent;
+    }
+    async function sendCommand(command) {
+        // In background context, use BackgroundAgent directly
+        if (inBackground) {
+            return getAgent().execute(command);
+        }
+        // In popup/content context, use message passing
+        return new Promise((resolve) => {
+            chrome.runtime.sendMessage({ type: 'btcp:command', command }, (response) => {
+                if (chrome.runtime.lastError) {
+                    resolve({
+                        id: command.id,
+                        success: false,
+                        error: chrome.runtime.lastError.message || 'Unknown error',
+                    });
+                }
+                else {
+                    const resp = response;
+                    if (resp.type === 'btcp:response') {
+                        resolve(resp.response);
+                    }
+                    else {
+                        // Unexpected pong response
+                        resolve({
+                            id: command.id,
+                            success: false,
+                            error: 'Unexpected response type',
+                        });
+                    }
+                }
+            });
+        });
+    }
+    function assertSuccess(response) {
+        if (!response.success) {
+            throw new Error(response.error);
+        }
+    }
+    return {
+        execute: sendCommand,
+        // Navigation
+        async navigate(url, options) {
+            return sendCommand({
+                id: generateCommandId(),
+                action: 'navigate',
+                url,
+                waitUntil: options?.waitUntil,
+            });
+        },
+        async back() {
+            return sendCommand({ id: generateCommandId(), action: 'back' });
+        },
+        async forward() {
+            return sendCommand({ id: generateCommandId(), action: 'forward' });
+        },
+        async reload(options) {
+            return sendCommand({
+                id: generateCommandId(),
+                action: 'reload',
+                bypassCache: options?.bypassCache,
+            });
+        },
+        async getUrl() {
+            const response = await sendCommand({ id: generateCommandId(), action: 'getUrl' });
+            assertSuccess(response);
+            return response.data.url;
+        },
+        async getTitle() {
+            const response = await sendCommand({ id: generateCommandId(), action: 'getTitle' });
+            assertSuccess(response);
+            return response.data.title;
+        },
+        // DOM
+        async snapshot(options) {
+            const response = await sendCommand({
+                id: generateCommandId(),
+                action: 'snapshot',
+                selector: options?.selector,
+                maxDepth: options?.maxDepth,
+                interactive: options?.interactive,
+                compact: options?.compact,
+                format: options?.format,
+            });
+            assertSuccess(response);
+            return response.data;
+        },
+        async click(selector, options) {
+            return sendCommand({
+                id: generateCommandId(),
+                action: 'click',
+                selector,
+                button: options?.button,
+            });
+        },
+        async type(selector, text, options) {
+            return sendCommand({
+                id: generateCommandId(),
+                action: 'type',
+                selector,
+                text,
+                delay: options?.delay,
+                clear: options?.clear,
+            });
+        },
+        async fill(selector, value) {
+            return sendCommand({
+                id: generateCommandId(),
+                action: 'fill',
+                selector,
+                value,
+            });
+        },
+        async getText(selector) {
+            const response = await sendCommand({
+                id: generateCommandId(),
+                action: 'getText',
+                selector,
+            });
+            assertSuccess(response);
+            return response.data.text;
+        },
+        async isVisible(selector) {
+            const response = await sendCommand({
+                id: generateCommandId(),
+                action: 'isVisible',
+                selector,
+            });
+            assertSuccess(response);
+            return response.data.visible;
+        },
+        // Tabs
+        async screenshot(options) {
+            const response = await sendCommand({
+                id: generateCommandId(),
+                action: 'screenshot',
+                format: options?.format,
+                quality: options?.quality,
+            });
+            assertSuccess(response);
+            return response.data.screenshot;
+        },
+        async tabNew(options) {
+            const response = await sendCommand({
+                id: generateCommandId(),
+                action: 'tabNew',
+                url: options?.url,
+                active: options?.active,
+            });
+            assertSuccess(response);
+            return response.data;
+        },
+        async tabClose(tabId) {
+            return sendCommand({
+                id: generateCommandId(),
+                action: 'tabClose',
+                tabId,
+            });
+        },
+        async tabSwitch(tabId) {
+            return sendCommand({
+                id: generateCommandId(),
+                action: 'tabSwitch',
+                tabId,
+            });
+        },
+        async tabList() {
+            const response = await sendCommand({
+                id: generateCommandId(),
+                action: 'tabList',
+            });
+            assertSuccess(response);
+            return response.data.tabs;
+        },
+        // Tab Groups & Sessions
+        async groupCreate(options) {
+            const response = await sendCommand({
+                id: generateCommandId(),
+                action: 'groupCreate',
+                tabIds: options?.tabIds,
+                title: options?.title,
+                color: options?.color,
+                collapsed: options?.collapsed,
+            });
+            assertSuccess(response);
+            return response.data;
+        },
+        async groupUpdate(groupId, options) {
+            const response = await sendCommand({
+                id: generateCommandId(),
+                action: 'groupUpdate',
+                groupId,
+                title: options.title,
+                color: options.color,
+                collapsed: options.collapsed,
+            });
+            assertSuccess(response);
+            return response.data;
+        },
+        async groupDelete(groupId) {
+            return sendCommand({
+                id: generateCommandId(),
+                action: 'groupDelete',
+                groupId,
+            });
+        },
+        async groupList() {
+            const response = await sendCommand({
+                id: generateCommandId(),
+                action: 'groupList',
+            });
+            assertSuccess(response);
+            return response.data.groups;
+        },
+        async groupAddTabs(groupId, tabIds) {
+            return sendCommand({
+                id: generateCommandId(),
+                action: 'groupAddTabs',
+                groupId,
+                tabIds,
+            });
+        },
+        async groupRemoveTabs(tabIds) {
+            return sendCommand({
+                id: generateCommandId(),
+                action: 'groupRemoveTabs',
+                tabIds,
+            });
+        },
+        async groupGet(groupId) {
+            const response = await sendCommand({
+                id: generateCommandId(),
+                action: 'groupGet',
+                groupId,
+            });
+            assertSuccess(response);
+            return response.data;
+        },
+        async sessionGetCurrent() {
+            const response = await sendCommand({
+                id: generateCommandId(),
+                action: 'sessionGetCurrent',
+            });
+            assertSuccess(response);
+            return response.data;
+        },
+        async popupInitialize() {
+            const response = await sendCommand({
+                id: generateCommandId(),
+                action: 'popupInitialize',
+            });
+            assertSuccess(response);
+            return response.data;
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,87 @@
+/**
+ * SessionManager - Manages tab groups and sessions for BTCP Browser Agent
+ */
+import type { GroupInfo, SessionInfo, GroupCreateOptions, GroupUpdateOptions } from './session-types.js';
+/**
+ * SessionManager handles Chrome tab group operations and session state
+ */
+export declare class SessionManager {
+    private activeSessionGroupId;
+    private sessionCounter;
+    private initialized;
+    constructor();
+    /**
+     * Restore session from storage
+     */
+    private restoreSession;
+    /**
+     * Persist session to storage
+     */
+    private persistSession;
+    /**
+     * Clear stored session
+     */
+    private clearStoredSession;
+    /**
+     * Reconnect to a specific session group
+     * Used when popup detects a stored session that isn't currently active
+     */
+    reconnectSession(groupId: number): Promise<boolean>;
+    /**
+     * Create a new tab group
+     */
+    createGroup(options?: GroupCreateOptions): Promise<GroupInfo>;
+    /**
+     * Update an existing tab group
+     */
+    updateGroup(groupId: number, options: GroupUpdateOptions): Promise<GroupInfo>;
+    /**
+     * Delete a tab group (closes all tabs in the group)
+     */
+    deleteGroup(groupId: number): Promise<void>;
+    /**
+     * List all tab groups
+     */
+    listGroups(): Promise<GroupInfo[]>;
+    /**
+     * Get a specific tab group
+     */
+    getGroup(groupId: number): Promise<GroupInfo>;
+    /**
+     * Add tabs to a group
+     */
+    addTabsToGroup(groupId: number, tabIds: number[]): Promise<void>;
+    /**
+     * Remove tabs from their group (ungroup them)
+     */
+    removeTabsFromGroup(tabIds: number[]): Promise<void>;
+    /**
+     * Get current active session info
+     */
+    getCurrentSession(): Promise<SessionInfo | null>;
+    /**
+     * Get the active session group ID
+     */
+    getActiveSessionGroupId(): number | null;
+    /**
+     * Set the active session group ID
+     */
+    setActiveSessionGroupId(groupId: number | null): void;
+    /**
+     * Add a tab to the active session (if one exists)
+     */
+    addTabToActiveSession(tabId: number): Promise<boolean>;
+    /**
+     * Generate a session name
+     */
+    private generateSessionName;
+    /**
+     * Map Chrome tab group to GroupInfo
+     */
+    private mapChromeGroupToGroupInfo;
+}
+/**
+ * Get the singleton SessionManager instance
+ */
+export declare function getSessionManager(): SessionManager;
+//# sourceMappingURL=session-manager.d.ts.map