btcp-browser-agent 0.1.7 → 0.1.8

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

@@ -42,6 +42,8 @@
 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 { createScriptMessenger, createMethodMessenger, type MessageDefinitions, type ScriptMessenger, type MethodMessenger, type ScriptMessengerOptions, type PayloadOf, type ResultOf, } from './script-messenger.js';
+export { createRemoteAgent, getBrowserToolDefinitions, mapToolToCommand, formatResponseForBTCP, type RemoteAgent, type RemoteAgentConfig, type RemoteAgentEvents, type BTCPToolDefinition, type BTCPContent, } from './remote.js';
 export { _BackgroundAgent as BackgroundAgent, _getBackgroundAgent as getBackgroundAgent, _setupMessageListener as setupMessageListener, _BrowserAgent as BrowserAgent, _getBrowserAgent as getBrowserAgent, };
 export { createContentAgent, type ContentAgent } from '../../core/dist/index.js';
 export type { SnapshotData, BoundingBox, Modifier, } from '../../core/dist/index.js';
@@ -205,6 +207,47 @@ export interface Client {
         initialized: boolean;
         reconnected: boolean;
     }>;
+    /**
+     * Inject a script into the page's main world
+     *
+     * The script runs in the page context (not the content script isolated world),
+     * allowing access to page-level APIs like window, fetch interceptors, etc.
+     *
+     * @example
+     * ```typescript
+     * await client.scriptInject(`
+     *   window.addEventListener('message', (event) => {
+     *     if (event.data?.type !== 'btcp:script-command') return;
+     *     if (event.data.scriptId !== 'helper') return;
+     *     const { commandId, payload } = event.data;
+     *     // Handle and ack
+     *     window.postMessage({ type: 'btcp:script-ack', commandId, result: { ok: true } }, '*');
+     *   });
+     * `, { scriptId: 'helper' });
+     * ```
+     */
+    scriptInject(code: string, options?: {
+        scriptId?: string;
+    }): Promise<{
+        scriptId: string;
+        injected: boolean;
+    }>;
+    /**
+     * Send a command to an injected script and wait for acknowledgment
+     *
+     * @example
+     * ```typescript
+     * const result = await client.scriptSend(
+     *   { action: 'getData', selector: '.items' },
+     *   { scriptId: 'helper', timeout: 5000 }
+     * );
+     * console.log(result); // { items: [...] }
+     * ```
+     */
+    scriptSend(payload: unknown, options?: {
+        scriptId?: string;
+        timeout?: number;
+    }): Promise<unknown>;
 }
 /**
  * Generate a unique command ID for BTCP commands

package/packages/extension/dist/index.js

@@ -42,6 +42,10 @@
 // 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 script messenger types and functions
+export { createScriptMessenger, createMethodMessenger, } from './script-messenger.js';
+// Re-export remote agent for BTCP protocol control
+export { createRemoteAgent, getBrowserToolDefinitions, mapToolToCommand, formatResponseForBTCP, } from './remote.js';
 // Re-export BackgroundAgent for background script usage
 export { _BackgroundAgent as BackgroundAgent, _getBackgroundAgent as getBackgroundAgent, _setupMessageListener as setupMessageListener, 
 // Deprecated aliases for backwards compatibility
@@ -353,6 +357,28 @@ export function createClient() {
             assertSuccess(response);
             return response.data;
         },
+        // Script Injection
+        async scriptInject(code, options) {
+            const response = await sendCommand({
+                id: generateCommandId(),
+                action: 'scriptInject',
+                code,
+                scriptId: options?.scriptId,
+            });
+            assertSuccess(response);
+            return response.data;
+        },
+        async scriptSend(payload, options) {
+            const response = await sendCommand({
+                id: generateCommandId(),
+                action: 'scriptSend',
+                payload,
+                scriptId: options?.scriptId,
+                timeout: options?.timeout,
+            });
+            assertSuccess(response);
+            return response.data.result;
+        },
     };
 }
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,133 @@
+/**
+ * @btcp/extension - Remote Control via BTCP Protocol
+ *
+ * Enables remote AI agents to control the browser via the Browser Tool Calling Protocol.
+ * Uses SSE for receiving commands and HTTP POST for sending results.
+ *
+ * @example
+ * ```typescript
+ * import { createRemoteAgent } from '@btcp/browser-agent/extension';
+ *
+ * const remote = createRemoteAgent({
+ *   serverUrl: 'http://localhost:8080',
+ *   sessionId: 'my-session',
+ * });
+ *
+ * await remote.connect();
+ * // Browser is now controllable by the BTCP server
+ * ```
+ */
+import type { Command, Response } from './types.js';
+import { type BackgroundAgent } from './background.js';
+/**
+ * BTCP tool definition schema
+ */
+export interface BTCPToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+/**
+ * BTCP content types for tool responses
+ */
+export type BTCPContent = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    data: string;
+    mimeType: string;
+} | {
+    type: 'resource';
+    uri: string;
+    mimeType?: string;
+    text?: string;
+};
+/**
+ * BTCP client configuration
+ */
+export interface RemoteAgentConfig {
+    /** BTCP server URL */
+    serverUrl: string;
+    /** Session ID for this browser instance */
+    sessionId?: string;
+    /** Enable auto-reconnect on disconnect (default: true) */
+    autoReconnect?: boolean;
+    /** Reconnect delay in ms (default: 1000) */
+    reconnectDelay?: number;
+    /** Max reconnect attempts (default: 10) */
+    maxReconnectAttempts?: number;
+    /** Connection timeout in ms (default: 30000) */
+    connectionTimeout?: number;
+    /** Enable debug logging (default: false) */
+    debug?: boolean;
+}
+/**
+ * BTCP client events
+ */
+export interface RemoteAgentEvents {
+    connect: () => void;
+    disconnect: (code?: number, reason?: string) => void;
+    error: (error: Error) => void;
+    toolCall: (name: string, args: Record<string, unknown>) => void;
+}
+/**
+ * Get all browser tool definitions for BTCP registration
+ */
+export declare function getBrowserToolDefinitions(): BTCPToolDefinition[];
+/**
+ * Map BTCP tool name and arguments to browser-agent Command
+ */
+export declare function mapToolToCommand(toolName: string, args: Record<string, unknown>): Command;
+/**
+ * Format response for BTCP protocol
+ */
+export declare function formatResponseForBTCP(response: Response): BTCPContent[];
+/**
+ * Remote agent state
+ */
+type ConnectionState = 'disconnected' | 'connecting' | 'connected';
+/**
+ * Remote agent for BTCP protocol control
+ */
+export interface RemoteAgent {
+    /** Connect to the BTCP server */
+    connect(): Promise<void>;
+    /** Disconnect from the BTCP server */
+    disconnect(): void;
+    /** Check if connected */
+    isConnected(): boolean;
+    /** Get current connection state */
+    getState(): ConnectionState;
+    /** Add event listener */
+    on<K extends keyof RemoteAgentEvents>(event: K, handler: RemoteAgentEvents[K]): void;
+    /** Remove event listener */
+    off<K extends keyof RemoteAgentEvents>(event: K, handler: RemoteAgentEvents[K]): void;
+    /** Get the underlying BackgroundAgent */
+    getAgent(): BackgroundAgent;
+    /** Get registered tool definitions */
+    getTools(): BTCPToolDefinition[];
+}
+/**
+ * Create a remote agent that connects to a BTCP server
+ *
+ * @example
+ * ```typescript
+ * const remote = createRemoteAgent({
+ *   serverUrl: 'http://localhost:8080',
+ *   sessionId: 'browser-1',
+ * });
+ *
+ * remote.on('connect', () => console.log('Connected!'));
+ * remote.on('toolCall', (name, args) => console.log('Tool called:', name, args));
+ *
+ * await remote.connect();
+ * ```
+ */
+export declare function createRemoteAgent(config: RemoteAgentConfig): RemoteAgent;
+export {};
+//# sourceMappingURL=remote.d.ts.map