popup.js

console.log('Popup JS loaded');

// Get the current active tab
async function get_current_tab() {
    var tabs = await browser.webfuseSession.getTabs()
    for (var i = 0; i < tabs.length; i++) {
        if (tabs[i].active) {
            return tabs[i];
        }
    }
    return null;
}

// Track pending automation requests
const pendingRequests = new Map();
let requestIdCounter = 0;

// Add listener once for automation results
browser.runtime.onMessage.addListener((message, sender) => {
  if (message.action === 'automationResult') {
    const request = pendingRequests.get(message.requestId);
    if (request) {
      pendingRequests.delete(message.requestId);
      clearTimeout(request.timeout);
      
      if (message.success) {
        request.resolve(message.data);
      } else {
        request.reject(new Error(message.error));
      }
    }
  }
});

document.addEventListener('DOMContentLoaded', () => {
const widget = document.querySelector('elevenlabs-convai');
if (widget) {
    // Listen for the widget's "call" event to trigger client-side tools
    widget.addEventListener('elevenlabs-convai:call', (event) => {
    event.detail.config.clientTools = {
        // Note: To use this example, the client tool called "redirectToExternalURL" (case-sensitive) must have been created with the configuration defined above.
        redirectToURL: ({ url }) => {
        console.log('redirecting to: ', url);
        browser.webfuseSession.relocate(url);
        console.log("redirecting....")
        //window.open(url, '_blank', 'noopener,noreferrer');
        },
        takeDomSnapshot: async () => {
          try {
            // Get current active tab
            const current_tab = get_current_tab();
            if (!current_tab) {
              throw new Error('No active tab found');
            }
            
            // Generate unique request ID
            const requestId = ++requestIdCounter;
            
            // Create a promise that will resolve when we get the result back
            const resultPromise = new Promise((resolve, reject) => {
              // Set up timeout
              const timeout = setTimeout(() => {
                pendingRequests.delete(requestId);
                reject(new Error('Timeout waiting for DOM snapshot'));
              }, 5000); 
              
              // Store the request
              pendingRequests.set(requestId, { resolve, reject, timeout });
              
              // Send message to content script with request ID
              browser.tabs.sendMessage(current_tab.ssid, {
                action: 'takeDomSnapshot',
                requestId: requestId
              });
            });
            
            return await resultPromise;
          } catch (error) {
            console.error('Error in takeDomSnapshot:', error);
            return {
              error: error.message
            };
          }
        },
        leftClick: async (params) => {
          try {
            const current_tab = get_current_tab();
            if (!current_tab) {
              throw new Error('No active tab found');
            }
            
            const requestId = ++requestIdCounter;
            
            const resultPromise = new Promise((resolve, reject) => {
              const timeout = setTimeout(() => {
                pendingRequests.delete(requestId);
                reject(new Error('Timeout waiting for left click'));
              }, 5000);
              
              pendingRequests.set(requestId, { resolve, reject, timeout });
              
              browser.tabs.sendMessage(current_tab.ssid, {
                action: 'leftClick',
                requestId: requestId,
                target: params.selector
              });
            });
            
            return await resultPromise;
          } catch (error) {
            console.error('Error in leftClick:', error);
            return {
              error: error.message
            };
          }
        },
        mouseMove: async (x, y) => {
          try {
            const current_tab = get_current_tab();
            if (!current_tab) {
              throw new Error('No active tab found');
            }
            
            const requestId = ++requestIdCounter;
            
            const resultPromise = new Promise((resolve, reject) => {
              const timeout = setTimeout(() => {
                pendingRequests.delete(requestId);
                reject(new Error('Timeout waiting for mouse move'));
              }, 5000);
              
              pendingRequests.set(requestId, { resolve, reject, timeout });
              
              browser.tabs.sendMessage(current_tab.ssid, {
                action: 'mouseMove',
                requestId: requestId,
                x: x,
                y: y
              });
            });
            
            return await resultPromise;
          } catch (error) {
            console.error('Error in mouseMove:', error);
            return {
              error: error.message
            };
          }
        },
        type: async (params) => {
          try {
            const current_tab = get_current_tab();
            if (!current_tab) {
              throw new Error('No active tab found');
            }
            
            const requestId = ++requestIdCounter;
            
            const resultPromise = new Promise((resolve, reject) => {
              const timeout = setTimeout(() => {
                pendingRequests.delete(requestId);
                reject(new Error('Timeout waiting for type'));
              }, 5000);
              
              pendingRequests.set(requestId, { resolve, reject, timeout });
             console.log('sending type message to content script', params.text, params.selector);
              browser.tabs.sendMessage(current_tab.ssid, {
                action: 'type',
                requestId: requestId,
                text: params.text,
                target: params.selector
              });
            });
            
            return await resultPromise;
          } catch (error) {
            console.error('Error in type:', error);
            return {
              error: error.message
            };
          }
        }
    };
    });
}
});