btcp-browser-agent 0.1.12 → 0.1.16

package/packages/extension/dist/transport/base-transport.js

@@ -0,0 +1,115 @@
+/**
+ * Base transport class with shared functionality
+ *
+ * Provides event handling, state management, and utility methods for transports.
+ */
+/**
+ * Abstract base class for transports
+ *
+ * Provides common functionality for event handling and state management.
+ * Subclasses must implement `send()`, `connect()`, and `disconnect()`.
+ */
+export class BaseTransport {
+    state = 'disconnected';
+    debug;
+    eventHandlers = new Map();
+    constructor(options = {}) {
+        this.debug = options.debug ?? false;
+    }
+    /**
+     * Get the current connection state
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Check if the transport is connected
+     */
+    isConnected() {
+        return this.state === 'connected';
+    }
+    /**
+     * Register an event handler
+     */
+    on(event, handler) {
+        if (!this.eventHandlers.has(event)) {
+            this.eventHandlers.set(event, new Set());
+        }
+        this.eventHandlers.get(event).add(handler);
+    }
+    /**
+     * Unregister an event handler
+     */
+    off(event, handler) {
+        const handlers = this.eventHandlers.get(event);
+        if (handlers) {
+            handlers.delete(handler);
+        }
+    }
+    /**
+     * Emit an event to all registered handlers
+     */
+    emit(event, ...args) {
+        const handlers = this.eventHandlers.get(event);
+        if (handlers) {
+            for (const handler of handlers) {
+                try {
+                    handler(...args);
+                }
+                catch (error) {
+                    this.log('error', `Error in event handler for "${event}":`, error);
+                }
+            }
+        }
+    }
+    /**
+     * Update the transport state and emit stateChange event
+     */
+    setState(newState) {
+        if (this.state !== newState) {
+            const oldState = this.state;
+            this.state = newState;
+            this.log('debug', `State changed: ${oldState} -> ${newState}`);
+            this.emit('stateChange', newState);
+            // Also emit specific events
+            if (newState === 'connected') {
+                this.emit('connected');
+            }
+            else if (newState === 'disconnected') {
+                this.emit('disconnected');
+            }
+        }
+    }
+    /**
+     * Log a message if debug is enabled
+     */
+    log(level, ...args) {
+        if (!this.debug && level === 'debug') {
+            return;
+        }
+        const prefix = `[${this.name}]`;
+        switch (level) {
+            case 'debug':
+            case 'info':
+                console.log(prefix, ...args);
+                break;
+            case 'warn':
+                console.warn(prefix, ...args);
+                break;
+            case 'error':
+                console.error(prefix, ...args);
+                break;
+        }
+    }
+    /**
+     * Create an error response with the given message
+     */
+    createErrorResponse(id, error) {
+        return {
+            id,
+            success: false,
+            error,
+        };
+    }
+}
+//# sourceMappingURL=base-transport.js.map

package/packages/extension/dist/transport/chrome-extension.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Chrome Extension Transport
+ *
+ * Transport implementation that uses chrome.runtime.sendMessage to communicate
+ * with the background script.
+ */
+import type { Command, Response } from '../types.js';
+import { BaseTransport } from './base-transport.js';
+import type { TransportOptions } from './types.js';
+/**
+ * Options for the Chrome extension transport
+ */
+export interface ChromeExtensionTransportOptions extends TransportOptions {
+    /**
+     * Whether to auto-connect on first send
+     * @default true
+     */
+    autoConnect?: boolean;
+}
+/**
+ * Chrome Extension Transport
+ *
+ * Uses chrome.runtime.sendMessage to send commands to the background script.
+ * This is the default transport for popup and content script contexts.
+ *
+ * @example
+ * ```typescript
+ * const transport = new ChromeExtensionTransport({ debug: true });
+ * await transport.connect();
+ * const response = await transport.send({ action: 'navigate', url: 'https://example.com' });
+ * ```
+ */
+export declare class ChromeExtensionTransport extends BaseTransport {
+    readonly name = "chrome-extension";
+    private autoConnect;
+    private initPromise;
+    constructor(options?: ChromeExtensionTransportOptions);
+    /**
+     * Connect to the background script
+     *
+     * Sends a popupInitialize command to reconnect to any existing session.
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect the transport
+     */
+    disconnect(): void;
+    /**
+     * Send a command to the background script
+     */
+    send(command: Command): Promise<Response>;
+    /**
+     * Ensure the transport is connected (lazy initialization)
+     */
+    private ensureConnected;
+    /**
+     * Send a command without auto-connect (used for popupInitialize itself)
+     */
+    private sendRaw;
+}
+/**
+ * Create a Chrome extension transport
+ *
+ * @example
+ * ```typescript
+ * const transport = createChromeExtensionTransport({ debug: true });
+ * const client = createClient({ transport });
+ * ```
+ */
+export declare function createChromeExtensionTransport(options?: ChromeExtensionTransportOptions): ChromeExtensionTransport;
+//# sourceMappingURL=chrome-extension.d.ts.map

package/packages/extension/dist/transport/chrome-extension.js

@@ -0,0 +1,131 @@
+/**
+ * Chrome Extension Transport
+ *
+ * Transport implementation that uses chrome.runtime.sendMessage to communicate
+ * with the background script.
+ */
+import { BaseTransport } from './base-transport.js';
+let commandIdCounter = 0;
+/**
+ * Generate a unique command ID for BTCP commands
+ */
+function generateCommandId() {
+    return `cmd_${Date.now()}_${commandIdCounter++}`;
+}
+/**
+ * Chrome Extension Transport
+ *
+ * Uses chrome.runtime.sendMessage to send commands to the background script.
+ * This is the default transport for popup and content script contexts.
+ *
+ * @example
+ * ```typescript
+ * const transport = new ChromeExtensionTransport({ debug: true });
+ * await transport.connect();
+ * const response = await transport.send({ action: 'navigate', url: 'https://example.com' });
+ * ```
+ */
+export class ChromeExtensionTransport extends BaseTransport {
+    name = 'chrome-extension';
+    autoConnect;
+    initPromise = null;
+    constructor(options = {}) {
+        super(options);
+        this.autoConnect = options.autoConnect ?? true;
+    }
+    /**
+     * Connect to the background script
+     *
+     * Sends a popupInitialize command to reconnect to any existing session.
+     */
+    async connect() {
+        if (this.state === 'connected' || this.state === 'connecting') {
+            return;
+        }
+        this.setState('connecting');
+        try {
+            // Send popupInitialize to reconnect to existing session
+            await this.sendRaw({
+                id: generateCommandId(),
+                action: 'popupInitialize',
+            });
+            this.setState('connected');
+        }
+        catch (error) {
+            // Silent fail - session will be created on first tool use if needed
+            // Still mark as connected since messaging works
+            this.log('debug', 'popupInitialize failed (session will be created on demand):', error);
+            this.setState('connected');
+        }
+    }
+    /**
+     * Disconnect the transport
+     */
+    disconnect() {
+        if (this.state === 'disconnected') {
+            return;
+        }
+        this.initPromise = null;
+        this.setState('disconnected');
+    }
+    /**
+     * Send a command to the background script
+     */
+    async send(command) {
+        // Auto-connect on first send if enabled
+        if (this.autoConnect && this.state === 'disconnected') {
+            await this.ensureConnected();
+        }
+        const id = command.id || generateCommandId();
+        return this.sendRaw({ ...command, id });
+    }
+    /**
+     * Ensure the transport is connected (lazy initialization)
+     */
+    async ensureConnected() {
+        if (this.state === 'connected') {
+            return;
+        }
+        if (this.initPromise === null) {
+            this.initPromise = this.connect();
+        }
+        return this.initPromise;
+    }
+    /**
+     * Send a command without auto-connect (used for popupInitialize itself)
+     */
+    sendRaw(command) {
+        const id = command.id || generateCommandId();
+        return new Promise((resolve) => {
+            chrome.runtime.sendMessage({ type: 'btcp:command', command: { ...command, id } }, (response) => {
+                if (chrome.runtime.lastError) {
+                    const error = chrome.runtime.lastError.message || 'Unknown error';
+                    this.log('debug', 'sendMessage error:', error);
+                    resolve(this.createErrorResponse(id, error));
+                }
+                else {
+                    const resp = response;
+                    if (resp?.type === 'btcp:response') {
+                        resolve(resp.response);
+                    }
+                    else {
+                        resolve(this.createErrorResponse(id, 'Unexpected response type'));
+                    }
+                }
+            });
+        });
+    }
+}
+/**
+ * Create a Chrome extension transport
+ *
+ * @example
+ * ```typescript
+ * const transport = createChromeExtensionTransport({ debug: true });
+ * const client = createClient({ transport });
+ * ```
+ */
+export function createChromeExtensionTransport(options = {}) {
+    return new ChromeExtensionTransport(options);
+}
+//# sourceMappingURL=chrome-extension.js.map

package/packages/extension/dist/transport/direct.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Direct Transport
+ *
+ * Transport implementation that calls BackgroundAgent.execute() directly,
+ * bypassing message passing. Use this in background script context for
+ * better performance.
+ */
+import type { BackgroundAgent } from '../background.js';
+import type { Command, Response } from '../types.js';
+import { BaseTransport } from './base-transport.js';
+import type { TransportOptions } from './types.js';
+/**
+ * Options for the direct transport
+ */
+export interface DirectTransportOptions extends TransportOptions {
+    /**
+     * The BackgroundAgent instance to use for executing commands.
+     * This is required since DirectTransport calls execute() directly.
+     */
+    agent: BackgroundAgent;
+}
+/**
+ * Direct Transport
+ *
+ * Executes commands directly via BackgroundAgent.execute() without
+ * any message passing. This is more efficient for background script
+ * contexts where the agent is available in-process.
+ *
+ * @example
+ * ```typescript
+ * import { getBackgroundAgent } from '@btcp/browser-agent/extension';
+ * import { createDirectTransport } from '@btcp/browser-agent/extension/transport';
+ *
+ * const agent = getBackgroundAgent();
+ * const transport = createDirectTransport({ agent });
+ * const client = createClient({ transport });
+ * ```
+ */
+export declare class DirectTransport extends BaseTransport {
+    readonly name = "direct";
+    private agent;
+    constructor(options: DirectTransportOptions);
+    /**
+     * Connect the transport (no-op for direct transport)
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect the transport
+     */
+    disconnect(): void;
+    /**
+     * Send a command directly to the BackgroundAgent
+     */
+    send(command: Command): Promise<Response>;
+}
+/**
+ * Create a direct transport
+ *
+ * @example
+ * ```typescript
+ * import { getBackgroundAgent } from '@btcp/browser-agent/extension';
+ * import { createDirectTransport } from '@btcp/browser-agent/extension/transport';
+ *
+ * const transport = createDirectTransport({ agent: getBackgroundAgent() });
+ * const client = createClient({ transport });
+ * ```
+ */
+export declare function createDirectTransport(options: DirectTransportOptions): DirectTransport;
+//# sourceMappingURL=direct.d.ts.map

package/packages/extension/dist/transport/direct.js

@@ -0,0 +1,90 @@
+/**
+ * Direct Transport
+ *
+ * Transport implementation that calls BackgroundAgent.execute() directly,
+ * bypassing message passing. Use this in background script context for
+ * better performance.
+ */
+import { BaseTransport } from './base-transport.js';
+let commandIdCounter = 0;
+/**
+ * Generate a unique command ID for BTCP commands
+ */
+function generateCommandId() {
+    return `direct_${Date.now()}_${commandIdCounter++}`;
+}
+/**
+ * Direct Transport
+ *
+ * Executes commands directly via BackgroundAgent.execute() without
+ * any message passing. This is more efficient for background script
+ * contexts where the agent is available in-process.
+ *
+ * @example
+ * ```typescript
+ * import { getBackgroundAgent } from '@btcp/browser-agent/extension';
+ * import { createDirectTransport } from '@btcp/browser-agent/extension/transport';
+ *
+ * const agent = getBackgroundAgent();
+ * const transport = createDirectTransport({ agent });
+ * const client = createClient({ transport });
+ * ```
+ */
+export class DirectTransport extends BaseTransport {
+    name = 'direct';
+    agent;
+    constructor(options) {
+        super(options);
+        this.agent = options.agent;
+        // Direct transport is always "connected" since it's in-process
+        this.setState('connected');
+    }
+    /**
+     * Connect the transport (no-op for direct transport)
+     */
+    async connect() {
+        // Direct transport is always connected
+        this.setState('connected');
+    }
+    /**
+     * Disconnect the transport
+     */
+    disconnect() {
+        this.setState('disconnected');
+    }
+    /**
+     * Send a command directly to the BackgroundAgent
+     */
+    async send(command) {
+        if (this.state !== 'connected') {
+            const id = command.id || generateCommandId();
+            return this.createErrorResponse(id, 'Transport is not connected');
+        }
+        try {
+            const id = command.id || generateCommandId();
+            return await this.agent.execute({ ...command, id });
+        }
+        catch (error) {
+            const id = command.id || generateCommandId();
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            this.log('error', 'Direct execute error:', error);
+            return this.createErrorResponse(id, message);
+        }
+    }
+}
+/**
+ * Create a direct transport
+ *
+ * @example
+ * ```typescript
+ * import { getBackgroundAgent } from '@btcp/browser-agent/extension';
+ * import { createDirectTransport } from '@btcp/browser-agent/extension/transport';
+ *
+ * const transport = createDirectTransport({ agent: getBackgroundAgent() });
+ * const client = createClient({ transport });
+ * ```
+ */
+export function createDirectTransport(options) {
+    return new DirectTransport(options);
+}
+//# sourceMappingURL=direct.js.map

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

@@ -0,0 +1,10 @@
+/**
+ * Transport module re-exports
+ *
+ * This module exports all transport-related types and implementations.
+ */
+export type { Transport, TransportState, TransportEvents, TransportOptions, } from './types.js';
+export { BaseTransport } from './base-transport.js';
+export { ChromeExtensionTransport, createChromeExtensionTransport, type ChromeExtensionTransportOptions, } from './chrome-extension.js';
+export { DirectTransport, createDirectTransport, type DirectTransportOptions, } from './direct.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/extension/dist/transport/index.js

@@ -0,0 +1,12 @@
+/**
+ * Transport module re-exports
+ *
+ * This module exports all transport-related types and implementations.
+ */
+// Base class (for custom transport implementations)
+export { BaseTransport } from './base-transport.js';
+// Chrome extension transport
+export { ChromeExtensionTransport, createChromeExtensionTransport, } from './chrome-extension.js';
+// Direct transport (in-process, for background scripts)
+export { DirectTransport, createDirectTransport, } from './direct.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,73 @@
+/**
+ * Transport abstraction for the client API
+ *
+ * This module defines the transport interface that allows the client to use
+ * different communication mechanisms (Chrome extension messaging, HTTP, WebSocket, etc.)
+ */
+import type { Command, Response } from '../types.js';
+/**
+ * Transport connection state
+ */
+export type TransportState = 'disconnected' | 'connecting' | 'connected' | 'error';
+/**
+ * Events emitted by transports
+ */
+export interface TransportEvents {
+    /** Transport connected successfully */
+    connected: () => void;
+    /** Transport disconnected */
+    disconnected: (reason?: string) => void;
+    /** Transport encountered an error */
+    error: (error: Error) => void;
+    /** Transport state changed */
+    stateChange: (state: TransportState) => void;
+}
+/**
+ * Base transport options shared by all transports
+ */
+export interface TransportOptions {
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * Transport interface for sending commands to the backend
+ *
+ * Transports handle the communication layer between the client and the
+ * command execution backend (background script, HTTP server, etc.)
+ */
+export interface Transport {
+    /**
+     * Human-readable name for this transport (e.g., 'chrome-extension', 'http')
+     */
+    readonly name: string;
+    /**
+     * Send a command and wait for the response
+     */
+    send(command: Command): Promise<Response>;
+    /**
+     * Connect the transport (if applicable)
+     * Some transports may be stateless and not require connection
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect the transport and clean up resources
+     */
+    disconnect(): void;
+    /**
+     * Get the current connection state
+     */
+    getState(): TransportState;
+    /**
+     * Check if the transport is currently connected
+     */
+    isConnected(): boolean;
+    /**
+     * Register an event handler
+     */
+    on<K extends keyof TransportEvents>(event: K, handler: TransportEvents[K]): void;
+    /**
+     * Unregister an event handler
+     */
+    off<K extends keyof TransportEvents>(event: K, handler: TransportEvents[K]): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/packages/extension/dist/transport/types.js

@@ -0,0 +1,8 @@
+/**
+ * Transport abstraction for the client API
+ *
+ * This module defines the transport interface that allows the client to use
+ * different communication mechanisms (Chrome extension messaging, HTTP, WebSocket, etc.)
+ */
+export {};
+//# sourceMappingURL=types.js.map