btcp-browser-agent 0.1.0 → 0.1.1

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

@@ -0,0 +1,18 @@
+/**
+ * @btcp/extension - Content Script
+ *
+ * Runs in web pages, handles DOM commands from the background script.
+ * Uses ContentAgent from @btcp/core for DOM operations.
+ */
+import { type ContentAgent, type Response } from '@btcp/core';
+import type { Command } from './types.js';
+/**
+ * Get or create the ContentAgent instance for this page
+ */
+declare function getContentAgent(): ContentAgent;
+/**
+ * Handle a command from the background script
+ */
+declare function handleCommand(command: Command): Promise<Response>;
+export { getContentAgent, handleCommand };
+//# sourceMappingURL=content.d.ts.map

package/packages/extension/dist/content.js

@@ -0,0 +1,149 @@
+/**
+ * @btcp/extension - Content Script
+ *
+ * Runs in web pages, handles DOM commands from the background script.
+ * Uses ContentAgent from @btcp/core for DOM operations.
+ */
+import { createContentAgent } from '@btcp/core';
+let agent = null;
+let isContentScriptReady = false;
+/**
+ * Get or create the ContentAgent instance for this page
+ */
+function getContentAgent() {
+    if (!agent) {
+        agent = createContentAgent(document, window);
+        isContentScriptReady = true;
+        console.log('[ContentScript] Agent initialized');
+    }
+    return agent;
+}
+// Initialize agent immediately
+getContentAgent();
+/**
+ * Check if a command is a core DOM command
+ */
+function isCoreCommand(command) {
+    const extensionActions = [
+        'navigate', 'back', 'forward', 'reload',
+        'getUrl', 'getTitle', 'screenshot',
+        'tabNew', 'tabClose', 'tabSwitch', 'tabList',
+    ];
+    return !extensionActions.includes(command.action);
+}
+/**
+ * Handle a command from the background script
+ */
+async function handleCommand(command) {
+    // Core DOM commands are handled by ContentAgent
+    if (isCoreCommand(command)) {
+        return getContentAgent().execute(command);
+    }
+    // Extension commands that need content script execution
+    switch (command.action) {
+        case 'getUrl':
+            return {
+                id: command.id,
+                success: true,
+                data: { url: window.location.href },
+            };
+        case 'getTitle':
+            return {
+                id: command.id,
+                success: true,
+                data: { title: document.title },
+            };
+        default:
+            // Forward to background script
+            return {
+                id: command.id,
+                success: false,
+                error: `Command ${command.action} must be handled by background script`,
+            };
+    }
+}
+/**
+ * Listen for messages from background script
+ */
+chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
+    const msg = message;
+    // Handle ping messages for heartbeat
+    if (msg.type === 'btcp:ping') {
+        sendResponse({ type: 'btcp:pong', ready: isContentScriptReady });
+        return true;
+    }
+    if (msg.type !== 'btcp:command') {
+        return false;
+    }
+    handleCommand(msg.command)
+        .then((response) => {
+        sendResponse({ type: 'btcp:response', response });
+    })
+        .catch((error) => {
+        sendResponse({
+            type: 'btcp:response',
+            response: {
+                id: msg.command.id,
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            },
+        });
+    });
+    // Return true to indicate async response
+    return true;
+});
+/**
+ * Also listen for postMessage from page scripts
+ * This allows scripts injected into the page to use the agent
+ */
+window.addEventListener('message', async (event) => {
+    if (event.source !== window)
+        return;
+    const msg = event.data;
+    if (msg?.type !== 'btcp:command')
+        return;
+    const response = await handleCommand(msg.command);
+    window.postMessage({
+        type: 'btcp:response',
+        response,
+    }, '*');
+});
+/**
+ * Lifecycle event listeners for session keep-alive
+ */
+// Detect page visibility changes
+document.addEventListener('visibilitychange', () => {
+    if (!document.hidden) {
+        console.log('[ContentScript] Page became visible, checking connection...');
+    }
+});
+// Detect freeze/resume events (Chrome 68+)
+document.addEventListener('freeze', () => {
+    console.log('[ContentScript] Page frozen');
+});
+document.addEventListener('resume', () => {
+    console.log('[ContentScript] Page resumed, re-initializing agent...');
+    // Re-initialize agent to ensure fresh state
+    agent = null;
+    getContentAgent();
+});
+// Clear refs on navigation (full page navigation)
+window.addEventListener('beforeunload', () => {
+    console.log('[ContentScript] Page navigating, clearing refs...');
+    const currentAgent = getContentAgent();
+    currentAgent.clearRefs();
+});
+// Detect SPA navigation (URL changes without full page reload)
+let lastUrl = window.location.href;
+setInterval(() => {
+    const currentUrl = window.location.href;
+    if (currentUrl !== lastUrl) {
+        console.log('[ContentScript] URL changed, clearing refs...', { from: lastUrl, to: currentUrl });
+        lastUrl = currentUrl;
+        const currentAgent = getContentAgent();
+        currentAgent.clearRefs();
+    }
+}, 1000);
+// Export for programmatic use
+export { getContentAgent, handleCommand };
+//# sourceMappingURL=content.js.map

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

@@ -0,0 +1,228 @@
+/**
+ * @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 type { Command, Response, TabInfo } from './types.js';
+import { BackgroundAgent as _BackgroundAgent, getBackgroundAgent as _getBackgroundAgent, setupMessageListener as _setupMessageListener, BrowserAgent as _BrowserAgent, getBrowserAgent as _getBrowserAgent } from './background.js';
+export * from './types.js';
+export { _BackgroundAgent as BackgroundAgent, _getBackgroundAgent as getBackgroundAgent, _setupMessageListener as setupMessageListener, _BrowserAgent as BrowserAgent, _getBrowserAgent as getBrowserAgent, };
+export { createContentAgent, type ContentAgent } from '@btcp/core';
+export type { SnapshotData, BoundingBox, Modifier, } from '@btcp/core';
+/**
+ * Client for sending commands to the extension background script
+ */
+export interface Client {
+    /**
+     * Execute a raw command
+     */
+    execute(command: Command): Promise<Response>;
+    /**
+     * Navigate to a URL
+     */
+    navigate(url: string, options?: {
+        waitUntil?: 'load' | 'domcontentloaded';
+    }): Promise<Response>;
+    /**
+     * Go back in history
+     */
+    back(): Promise<Response>;
+    /**
+     * Go forward in history
+     */
+    forward(): Promise<Response>;
+    /**
+     * Reload the page
+     */
+    reload(options?: {
+        bypassCache?: boolean;
+    }): Promise<Response>;
+    /**
+     * Get the current URL
+     */
+    getUrl(): Promise<string>;
+    /**
+     * Get the page title
+     */
+    getTitle(): Promise<string>;
+    /**
+     * Take a snapshot of the page
+     */
+    snapshot(options?: {
+        selector?: string;
+        maxDepth?: number;
+        interactive?: boolean;
+        compact?: boolean;
+        format?: 'tree' | 'html';
+    }): Promise<string>;
+    /**
+     * Click an element
+     */
+    click(selector: string, options?: {
+        button?: 'left' | 'right' | 'middle';
+    }): Promise<Response>;
+    /**
+     * Type text into an element
+     */
+    type(selector: string, text: string, options?: {
+        delay?: number;
+        clear?: boolean;
+    }): Promise<Response>;
+    /**
+     * Fill an input with a value
+     */
+    fill(selector: string, value: string): Promise<Response>;
+    /**
+     * Get text content of an element
+     */
+    getText(selector: string): Promise<string | null>;
+    /**
+     * Check if element is visible
+     */
+    isVisible(selector: string): Promise<boolean>;
+    /**
+     * Take a screenshot
+     */
+    screenshot(options?: {
+        format?: 'png' | 'jpeg';
+        quality?: number;
+    }): Promise<string>;
+    /**
+     * Open a new tab
+     */
+    tabNew(options?: {
+        url?: string;
+        active?: boolean;
+    }): Promise<{
+        tabId: number;
+        url?: string;
+    }>;
+    /**
+     * Close a tab
+     */
+    tabClose(tabId?: number): Promise<Response>;
+    /**
+     * Switch to a tab
+     */
+    tabSwitch(tabId: number): Promise<Response>;
+    /**
+     * List all tabs
+     */
+    tabList(): Promise<TabInfo[]>;
+    /**
+     * Create a new tab group
+     */
+    groupCreate(options?: {
+        tabIds?: number[];
+        title?: string;
+        color?: string;
+        collapsed?: boolean;
+    }): Promise<{
+        group: import('./session-types.js').GroupInfo;
+    }>;
+    /**
+     * Update a tab group
+     */
+    groupUpdate(groupId: number, options: {
+        title?: string;
+        color?: string;
+        collapsed?: boolean;
+    }): Promise<{
+        group: import('./session-types.js').GroupInfo;
+    }>;
+    /**
+     * Delete a tab group (closes all tabs)
+     */
+    groupDelete(groupId: number): Promise<Response>;
+    /**
+     * List all tab groups
+     */
+    groupList(): Promise<import('./session-types.js').GroupInfo[]>;
+    /**
+     * Add tabs to a group
+     */
+    groupAddTabs(groupId: number, tabIds: number[]): Promise<Response>;
+    /**
+     * Remove tabs from their group
+     */
+    groupRemoveTabs(tabIds: number[]): Promise<Response>;
+    /**
+     * Get a specific tab group
+     */
+    groupGet(groupId: number): Promise<{
+        group: import('./session-types.js').GroupInfo;
+    }>;
+    /**
+     * Get current active session
+     */
+    sessionGetCurrent(): Promise<{
+        session: import('./session-types.js').SessionInfo | null;
+    }>;
+    /**
+     * Initialize popup (triggers session reconnection check)
+     */
+    popupInitialize(): Promise<{
+        initialized: boolean;
+        reconnected: boolean;
+    }>;
+}
+/**
+ * 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 declare function createClient(): Client;
+//# sourceMappingURL=index.d.ts.map