btcp-browser-agent 0.1.14 → 0.1.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "btcp-browser-agent",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Give AI agents the power to control browsers. A foundation for building agentic systems with smart DOM snapshots and stable element references.",
   "type": "module",
   "main": "dist/index.js",

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

@@ -40,6 +40,7 @@
  * ```
  */
 import type { Command, Response } from './types.js';
+import type { Transport } from './transport/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';
@@ -47,6 +48,7 @@ export { createRemoteAgent, getBrowserToolDefinitions, mapToolToCommand, formatR
 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';
+export * from './transport/index.js';
 /**
  * Client for sending commands to the extension background script
  */
@@ -147,6 +149,24 @@ export interface Client {
      */
     evaluate(expression: string): Promise<unknown>;
 }
+/**
+ * Options for creating a client
+ */
+export interface CreateClientOptions {
+    /**
+     * Transport to use for sending commands.
+     * Defaults to ChromeExtensionTransport.
+     *
+     * @example Using direct transport in background script:
+     * ```typescript
+     * import { createClient, createDirectTransport, getBackgroundAgent } from '@btcp/browser-agent/extension';
+     *
+     * const transport = createDirectTransport({ agent: getBackgroundAgent() });
+     * const client = createClient({ transport });
+     * ```
+     */
+    transport?: Transport;
+}
 /**
  * Generate a unique command ID for BTCP commands
  */
@@ -154,24 +174,31 @@ export declare function generateCommandId(): string;
 /**
  * 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
+ * By default uses ChromeExtensionTransport for popup/content script contexts.
+ * Pass a custom transport for different communication mechanisms.
  *
- * @example Popup usage:
+ * @example Default (Chrome Extension):
  * ```typescript
  * import { createClient } from '@btcp/browser-agent/extension';
  * const client = createClient();
  * await client.navigate('https://example.com');
  * ```
  *
- * @example Background script usage:
+ * @example With explicit transport:
  * ```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');
+ * import { createClient, createChromeExtensionTransport } from '@btcp/browser-agent/extension';
+ *
+ * const transport = createChromeExtensionTransport({ debug: true });
+ * const client = createClient({ transport });
+ * ```
+ *
+ * @example Direct transport (background script):
+ * ```typescript
+ * import { createClient, createDirectTransport, getBackgroundAgent } from '@btcp/browser-agent/extension';
+ *
+ * const transport = createDirectTransport({ agent: getBackgroundAgent() });
+ * const client = createClient({ transport });
  * ```
  */
-export declare function createClient(): Client;
+export declare function createClient(options?: CreateClientOptions): Client;
 //# sourceMappingURL=index.d.ts.map

package/packages/extension/dist/index.js

@@ -39,6 +39,7 @@
  * await client.click('@ref:5');
  * ```
  */
+import { ChromeExtensionTransport } from './transport/chrome-extension.js';
 // 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';
@@ -52,6 +53,8 @@ export { _BackgroundAgent as BackgroundAgent, _getBackgroundAgent as getBackgrou
 _BrowserAgent as BrowserAgent, _getBrowserAgent as getBrowserAgent, };
 // Re-export ContentAgent for content script usage
 export { createContentAgent } from '../../core/dist/index.js';
+// Re-export transport module
+export * from './transport/index.js';
 let commandIdCounter = 0;
 /**
  * Generate a unique command ID for BTCP commands
@@ -59,79 +62,41 @@ let commandIdCounter = 0;
 export 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
+ * By default uses ChromeExtensionTransport for popup/content script contexts.
+ * Pass a custom transport for different communication mechanisms.
  *
- * @example Popup usage:
+ * @example Default (Chrome Extension):
  * ```typescript
  * import { createClient } from '@btcp/browser-agent/extension';
  * const client = createClient();
  * await client.navigate('https://example.com');
  * ```
  *
- * @example Background script usage:
+ * @example With explicit transport:
  * ```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');
+ * import { createClient, createChromeExtensionTransport } from '@btcp/browser-agent/extension';
+ *
+ * const transport = createChromeExtensionTransport({ debug: true });
+ * const client = createClient({ transport });
+ * ```
+ *
+ * @example Direct transport (background script):
+ * ```typescript
+ * import { createClient, createDirectTransport, getBackgroundAgent } from '@btcp/browser-agent/extension';
+ *
+ * const transport = createDirectTransport({ agent: getBackgroundAgent() });
+ * const client = createClient({ transport });
  * ```
  */
-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;
-    }
+export function createClient(options = {}) {
+    // Default to Chrome extension transport
+    const transport = options.transport ?? new ChromeExtensionTransport();
     async function sendCommand(command) {
-        // In background context, use BackgroundAgent directly
-        if (inBackground) {
-            return getAgent().execute(command);
-        }
-        // In popup/content context, use message passing
         const id = command.id || generateCommandId();
-        return new Promise((resolve) => {
-            chrome.runtime.sendMessage({ type: 'btcp:command', command: { ...command, id } }, (response) => {
-                if (chrome.runtime.lastError) {
-                    resolve({
-                        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,
-                            success: false,
-                            error: 'Unexpected response type',
-                        });
-                    }
-                }
-            });
-        });
+        return transport.send({ ...command, id });
     }
     function assertSuccess(response) {
         if (!response.success) {

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

@@ -0,0 +1,65 @@
+/**
+ * Base transport class with shared functionality
+ *
+ * Provides event handling, state management, and utility methods for transports.
+ */
+import type { Command, Response } from '../types.js';
+import type { Transport, TransportEvents, TransportOptions, TransportState } from './types.js';
+/**
+ * Abstract base class for transports
+ *
+ * Provides common functionality for event handling and state management.
+ * Subclasses must implement `send()`, `connect()`, and `disconnect()`.
+ */
+export declare abstract class BaseTransport implements Transport {
+    abstract readonly name: string;
+    protected state: TransportState;
+    protected debug: boolean;
+    private eventHandlers;
+    constructor(options?: TransportOptions);
+    /**
+     * Send a command - must be implemented by subclasses
+     */
+    abstract send(command: Command): Promise<Response>;
+    /**
+     * Connect the transport - must be implemented by subclasses
+     */
+    abstract connect(): Promise<void>;
+    /**
+     * Disconnect the transport - must be implemented by subclasses
+     */
+    abstract disconnect(): void;
+    /**
+     * Get the current connection state
+     */
+    getState(): TransportState;
+    /**
+     * Check if the transport is 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;
+    /**
+     * Emit an event to all registered handlers
+     */
+    protected emit<K extends keyof TransportEvents>(event: K, ...args: Parameters<TransportEvents[K]>): void;
+    /**
+     * Update the transport state and emit stateChange event
+     */
+    protected setState(newState: TransportState): void;
+    /**
+     * Log a message if debug is enabled
+     */
+    protected log(level: 'debug' | 'info' | 'warn' | 'error', ...args: unknown[]): void;
+    /**
+     * Create an error response with the given message
+     */
+    protected createErrorResponse(id: string, error: string): Response;
+}
+//# sourceMappingURL=base-transport.d.ts.map

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