btcp-browser-agent 0.1.14 → 0.1.17

package/packages/extension/dist/session-manager.js

@@ -15,6 +15,7 @@ export class SessionManager {
     initializationPromise;
     maxSession;
     maxOpenTab;
+    ensureSessionPromise = null;
     constructor(options = {}) {
         this.maxSession = options.maxSession ?? 1;
         this.maxOpenTab = options.maxOpenTab ?? 1;
@@ -222,17 +223,21 @@ export class SessionManager {
     }
     /**
      * Create a new tab group
+     * @param options Group creation options
+     * @param internal If true, bypasses session limit check (used by ensureSession)
      */
-    async createGroup(options = {}) {
+    async createGroup(options = {}, internal = false) {
         // Wait for initialization to complete first
         await this.waitForInitialization();
-        console.log('[SessionManager] createGroup called with options:', options);
-        // Check if we can create a new session
-        const canCreate = await this.canCreateSession();
-        if (!canCreate) {
-            const count = await this.getSessionCount();
-            throw new Error(`Maximum session limit reached (${count}/${this.maxSession}). ` +
-                `Close an existing session before creating a new one.`);
+        console.log('[SessionManager] createGroup called with options:', options, 'internal:', internal);
+        // Check if we can create a new session (skip if internal call from ensureSession)
+        if (!internal) {
+            const canCreate = await this.canCreateSession();
+            if (!canCreate) {
+                const count = await this.getSessionCount();
+                throw new Error(`Maximum session limit reached (${count}/${this.maxSession}). ` +
+                    `Close an existing session before creating a new one.`);
+            }
         }
         const { tabIds = [], title = this.generateSessionName(), color = 'blue', collapsed = false, } = options;
         // If no tabIds provided, create a new blank tab for the session
@@ -512,18 +517,42 @@ export class SessionManager {
     /**
      * Ensure a session exists - restore from storage, use existing, or create new
      * Returns the session group ID (creates if needed)
+     *
+     * This method is atomic - concurrent calls will wait for the same promise
      */
     async ensureSession() {
+        // Return existing promise if already in progress
+        if (this.ensureSessionPromise) {
+            console.log('[SessionManager] ensureSession already in progress, waiting...');
+            return this.ensureSessionPromise;
+        }
+        // Create new promise and store it
+        this.ensureSessionPromise = this._doEnsureSession();
+        try {
+            return await this.ensureSessionPromise;
+        }
+        finally {
+            // Clear promise when done
+            this.ensureSessionPromise = null;
+        }
+    }
+    /**
+     * Internal implementation of ensureSession
+     */
+    async _doEnsureSession() {
         await this.waitForInitialization();
+        console.log('[SessionManager] Starting ensureSession...');
         // Step 1: Already have active session
         if (this.activeSessionGroupId !== null) {
             // Verify it still exists
             try {
                 await chrome.tabGroups.get(this.activeSessionGroupId);
+                console.log('[SessionManager] Active session still valid:', this.activeSessionGroupId);
                 return this.activeSessionGroupId;
             }
             catch {
                 // Group no longer exists, continue to restore/create
+                console.log('[SessionManager] Active session no longer exists');
                 this.activeSessionGroupId = null;
             }
         }
@@ -531,23 +560,33 @@ export class SessionManager {
         const result = await chrome.storage.session.get(SESSION_STORAGE_KEY);
         const stored = result[SESSION_STORAGE_KEY];
         if (stored?.groupId) {
+            console.log('[SessionManager] Step 2: Attempting to reconnect to stored session:', stored.groupId);
             const reconnected = await this.reconnectSession(stored.groupId);
             if (reconnected && this.activeSessionGroupId !== null) {
+                console.log('[SessionManager] Reconnected to stored session:', this.activeSessionGroupId);
                 return this.activeSessionGroupId;
             }
         }
         // Step 3: Find existing BTCP group
+        console.log('[SessionManager] Step 3: Looking for existing BTCP groups...');
         const groups = await chrome.tabGroups.query({});
+        console.log('[SessionManager] Found tab groups:', groups.map(g => ({ id: g.id, title: g.title })));
         const btcpGroup = groups.find(g => g.title?.startsWith('BTCP'));
         if (btcpGroup) {
+            console.log('[SessionManager] Found existing BTCP group:', btcpGroup.id, btcpGroup.title);
             const used = await this.useExistingGroupAsSession(btcpGroup.id);
             if (used && this.activeSessionGroupId !== null) {
+                console.log('[SessionManager] Successfully reused existing session:', this.activeSessionGroupId);
                 return this.activeSessionGroupId;
             }
         }
-        // Step 4: Create new session
+        else {
+            console.log('[SessionManager] No existing BTCP groups found');
+        }
+        // Step 4: Create new session (bypass limit check since we already tried to reuse)
         console.log('[SessionManager] No existing session found, creating new one...');
-        const newGroup = await this.createGroup({ color: 'blue' });
+        const newGroup = await this.createGroup({ color: 'blue' }, true); // internal=true bypasses limit
+        console.log('[SessionManager] Created new session:', newGroup.id);
         return newGroup.id;
     }
     /**

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