more tools

opendia-extension/background.js

@@ -213,11 +213,9 @@ function getAvailableTools() {
         required: ["condition_type"]
       }
     },
-    
-    // Essential legacy tools for compatibility
     {
       name: "browser_navigate",
-      description: "Navigate to a URL in the active tab (legacy)",
+      description: "Navigate to a URL in the active tab",
       inputSchema: {
         type: "object",
         properties: {
@@ -226,16 +224,85 @@ function getAvailableTools() {
         required: ["url"],
       },
     },
+    
+    // Tab Management Tools
     {
-      name: "browser_execute_script",
-      description: "Execute JavaScript in the active tab",
+      name: "tab_create",
+      description: "Create a new tab with optional URL and activation",
       inputSchema: {
         type: "object",
         properties: {
-          code: { type: "string", description: "JavaScript code to execute" },
+          url: {
+            type: "string",
+            description: "URL to open in the new tab (optional)"
+          },
+          active: {
+            type: "boolean",
+            default: true,
+            description: "Whether to activate the new tab"
+          },
+          wait_for: {
+            type: "string",
+            description: "CSS selector to wait for after tab creation (if URL provided)"
+          },
+          timeout: {
+            type: "number",
+            default: 10000,
+            description: "Maximum wait time in milliseconds"
+          }
+        }
+      }
+    },
+    {
+      name: "tab_close",
+      description: "Close specific tab(s) by ID or close current tab",
+      inputSchema: {
+        type: "object",
+        properties: {
+          tab_id: {
+            type: "number",
+            description: "Specific tab ID to close (optional, closes current tab if not provided)"
+          },
+          tab_ids: {
+            type: "array",
+            items: { type: "number" },
+            description: "Array of tab IDs to close multiple tabs"
+          }
+        }
+      }
+    },
+    {
+      name: "tab_list",
+      description: "Get list of all open tabs with their details",
+      inputSchema: {
+        type: "object",
+        properties: {
+          current_window_only: {
+            type: "boolean",
+            default: true,
+            description: "Only return tabs from the current window"
+          },
+          include_details: {
+            type: "boolean",
+            default: true,
+            description: "Include additional tab details (title, favicon, etc.)"
+          }
+        }
+      }
+    },
+    {
+      name: "tab_switch",
+      description: "Switch to a specific tab by ID",
+      inputSchema: {
+        type: "object",
+        properties: {
+          tab_id: {
+            type: "number",
+            description: "Tab ID to switch to"
+          }
         },
-        required: ["code"],
-      },
+        required: ["tab_id"]
+      }
     },
     
     // Element State Tools
@@ -253,24 +320,175 @@ function getAvailableTools() {
         required: ["element_id"]
       }
     },
-
-    // Analytics and Performance Tools
+    // Workspace and Reference Management Tools
     {
-      name: "get_analytics",
-      description: "Get token usage analytics and performance metrics",
+      name: "get_bookmarks",
+      description: "Get all bookmarks or search for specific bookmarks",
       inputSchema: {
         type: "object",
-        properties: {},
-        additionalProperties: false
+        properties: {
+          query: {
+            type: "string",
+            description: "Search query for bookmarks (optional)"
+          }
+        }
       }
     },
     {
-      name: "clear_analytics",
-      description: "Clear all analytics data and reset performance tracking",
+      name: "add_bookmark",
+      description: "Add a new bookmark",
       inputSchema: {
         type: "object",
-        properties: {},
-        additionalProperties: false
+        properties: {
+          title: {
+            type: "string",
+            description: "Title of the bookmark"
+          },
+          url: {
+            type: "string",
+            description: "URL of the bookmark"
+          },
+          parentId: {
+            type: "string",
+            description: "ID of the parent folder (optional)"
+          }
+        },
+        required: ["title", "url"]
+      }
+    },
+    {
+      name: "get_history",
+      description: "Search browser history with comprehensive filters for finding previous work by date/keywords",
+      inputSchema: {
+        type: "object",
+        properties: {
+          keywords: {
+            type: "string",
+            description: "Search keywords to match in page titles and URLs"
+          },
+          start_date: {
+            type: "string",
+            format: "date-time",
+            description: "Start date for history search (ISO 8601 format)"
+          },
+          end_date: {
+            type: "string",
+            format: "date-time",
+            description: "End date for history search (ISO 8601 format)"
+          },
+          domains: {
+            type: "array",
+            items: { type: "string" },
+            description: "Filter by specific domains (e.g., ['github.com', 'stackoverflow.com'])"
+          },
+          min_visit_count: {
+            type: "number",
+            default: 1,
+            description: "Minimum visit count threshold"
+          },
+          max_results: {
+            type: "number",
+            default: 50,
+            maximum: 500,
+            description: "Maximum number of results to return"
+          },
+          sort_by: {
+            type: "string",
+            enum: ["visit_time", "visit_count", "title"],
+            default: "visit_time",
+            description: "Sort results by visit time, visit count, or title"
+          },
+          sort_order: {
+            type: "string",
+            enum: ["desc", "asc"],
+            default: "desc",
+            description: "Sort order (descending or ascending)"
+          }
+        }
+      }
+    },
+    {
+      name: "get_selected_text",
+      description: "Get the currently selected text on the page",
+      inputSchema: {
+        type: "object",
+        properties: {
+          include_metadata: {
+            type: "boolean",
+            default: true,
+            description: "Include metadata about the selection (element info, position, etc.)"
+          },
+          max_length: {
+            type: "number",
+            default: 10000,
+            description: "Maximum length of text to return"
+          }
+        }
+      }
+    },
+    {
+      name: "page_scroll",
+      description: "Scroll the page in various directions and amounts - critical for long pages",
+      inputSchema: {
+        type: "object",
+        properties: {
+          direction: {
+            type: "string",
+            enum: ["up", "down", "left", "right", "top", "bottom"],
+            default: "down",
+            description: "Direction to scroll"
+          },
+          amount: {
+            type: "string",
+            enum: ["small", "medium", "large", "page", "custom"],
+            default: "medium",
+            description: "Amount to scroll"
+          },
+          pixels: {
+            type: "number",
+            description: "Custom pixel amount (when amount is 'custom')"
+          },
+          smooth: {
+            type: "boolean",
+            default: true,
+            description: "Use smooth scrolling animation"
+          },
+          element_id: {
+            type: "string",
+            description: "Scroll to specific element (overrides direction/amount)"
+          },
+          wait_after: {
+            type: "number",
+            default: 500,
+            description: "Milliseconds to wait after scrolling"
+          }
+        }
+      }
+    },
+    {
+      name: "get_page_links",
+      description: "Get all hyperlinks on the current page with filtering options",
+      inputSchema: {
+        type: "object",
+        properties: {
+          link_type: {
+            type: "string",
+            enum: ["all", "internal", "external"],
+            default: "all",
+            description: "Filter by internal/external links"
+          },
+          domains: {
+            type: "array",
+            items: { type: "string" },
+            description: "Filter by specific domains (optional)"
+          },
+          max_results: {
+            type: "number",
+            default: 50,
+            maximum: 200,
+            description: "Maximum links to return"
+          }
+        }
       }
     },
   ];
@@ -303,26 +521,46 @@ async function handleMCPRequest(message) {
       case "page_wait_for":
         result = await sendToContentScript('wait_for', params);
         break;
-        
-      // Essential legacy tools for compatibility
       case "browser_navigate":
         result = await navigateToUrl(params.url);
         break;
-      case "browser_execute_script":
-        result = await executeScript(params.code);
+        
+      // Tab management tools
+      case "tab_create":
+        result = await createTab(params);
+        break;
+      case "tab_close":
+        result = await closeTabs(params);
+        break;
+      case "tab_list":
+        result = await listTabs(params);
+        break;
+      case "tab_switch":
+        result = await switchToTab(params.tab_id);
         break;
         
       // Element state tools
       case "element_get_state":
         result = await sendToContentScript('get_element_state', params);
         break;
-        
-      // Analytics tools
-      case "get_analytics":
-        result = await sendToContentScript('get_analytics', {});
+      // Workspace and Reference Management Tools
+      case "get_bookmarks":
+        result = await getBookmarks(params);
         break;
-      case "clear_analytics":
-        result = await sendToContentScript('clear_analytics', {});
+      case "add_bookmark":
+        result = await addBookmark(params);
+        break;
+      case "get_history":
+        result = await getHistory(params);
+        break;
+      case "get_selected_text":
+        result = await getSelectedText(params);
+        break;
+      case "page_scroll":
+        result = await sendToContentScript('page_scroll', params);
+        break;
+      case "get_page_links":
+        result = await sendToContentScript('get_page_links', params);
         break;
       default:
         throw new Error(`Unknown method: ${method}`);
@@ -364,10 +602,10 @@ async function sendToContentScript(action, data) {
     chrome.tabs.sendMessage(activeTab.id, { action, data }, (response) => {
       if (chrome.runtime.lastError) {
         reject(new Error(chrome.runtime.lastError.message));
-      } else if (response.success) {
+      } else if (response && response.success) {
         resolve(response.data);
       } else {
-        reject(new Error(response.error || 'Unknown error'));
+        reject(new Error(response?.error || 'Unknown error'));
       }
     });
   });
@@ -421,58 +659,473 @@ async function waitForElement(tabId, selector, timeout = 5000) {
   throw new Error(`Timeout waiting for element: ${selector}`);
 }
 
-async function executeScript(code) {
-  const [activeTab] = await chrome.tabs.query({
-    active: true,
-    currentWindow: true,
+// Tab Management Functions
+async function createTab(params) {
+  const { url, active = true, wait_for, timeout = 10000 } = params;
+  
+  const createProperties = { active };
+  if (url) {
+    createProperties.url = url;
+  }
+  
+  const newTab = await chrome.tabs.create(createProperties);
+  
+  // If URL was provided and wait_for is specified, wait for the element
+  if (url && wait_for) {
+    try {
+      await waitForElement(newTab.id, wait_for, timeout);
+    } catch (error) {
+      return {
+        success: true,
+        tab_id: newTab.id,
+        url: newTab.url,
+        warning: `Tab created but wait condition failed: ${error.message}`
+      };
+    }
+  }
+  
+  return {
+    success: true,
+    tab_id: newTab.id,
+    url: newTab.url || 'about:blank',
+    active: newTab.active,
+    title: newTab.title || 'New Tab'
+  };
+}
+
+async function closeTabs(params) {
+  const { tab_id, tab_ids } = params;
+  
+  let tabsToClose = [];
+  
+  if (tab_ids && Array.isArray(tab_ids)) {
+    // Close multiple tabs
+    tabsToClose = tab_ids;
+  } else if (tab_id) {
+    // Close specific tab
+    tabsToClose = [tab_id];
+  } else {
+    // Close current tab
+    const [activeTab] = await chrome.tabs.query({
+      active: true,
+      currentWindow: true,
+    });
+    if (activeTab) {
+      tabsToClose = [activeTab.id];
+    }
+  }
+  
+  if (tabsToClose.length === 0) {
+    throw new Error('No tabs specified to close');
+  }
+  
+  // Close tabs
+  await chrome.tabs.remove(tabsToClose);
+  
+  return {
+    success: true,
+    closed_tabs: tabsToClose,
+    count: tabsToClose.length
+  };
+}
+
+async function listTabs(params) {
+  const { current_window_only = true, include_details = true } = params;
+  
+  const queryOptions = {};
+  if (current_window_only) {
+    queryOptions.currentWindow = true;
+  }
+  
+  const tabs = await chrome.tabs.query(queryOptions);
+  
+  const tabList = tabs.map(tab => {
+    const basicInfo = {
+      id: tab.id,
+      url: tab.url,
+      active: tab.active,
+      title: tab.title
+    };
+    
+    if (include_details) {
+      return {
+        ...basicInfo,
+        index: tab.index,
+        pinned: tab.pinned,
+        status: tab.status,
+        favIconUrl: tab.favIconUrl,
+        windowId: tab.windowId,
+        incognito: tab.incognito
+      };
+    }
+    
+    return basicInfo;
   });
   
+  return {
+    success: true,
+    tabs: tabList,
+    count: tabList.length,
+    active_tab: tabs.find(tab => tab.active)?.id || null
+  };
+}
+
+async function switchToTab(tabId) {
+  // First, get tab info to ensure it exists
+  const tab = await chrome.tabs.get(tabId);
+  
+  if (!tab) {
+    throw new Error(`Tab with ID ${tabId} not found`);
+  }
+  
+  // Switch to the tab
+  await chrome.tabs.update(tabId, { active: true });
+  
+  // Also focus the window containing the tab
+  await chrome.windows.update(tab.windowId, { focused: true });
+  
+  return {
+    success: true,
+    tab_id: tabId,
+    url: tab.url,
+    title: tab.title,
+    window_id: tab.windowId
+  };
+}
+
+// Workspace and Reference Management Functions
+async function getBookmarks(params) {
+  const { query } = params;
+  
+  let bookmarks;
+  if (query) {
+    bookmarks = await chrome.bookmarks.search(query);
+  } else {
+    bookmarks = await chrome.bookmarks.getTree();
+  }
+  
+  return {
+    success: true,
+    bookmarks,
+    count: bookmarks.length
+  };
+}
+
+async function addBookmark(params) {
+  const { title, url, parentId } = params;
+  
+  const bookmark = await chrome.bookmarks.create({
+    title,
+    url,
+    parentId
+  });
+  
+  return {
+    success: true,
+    bookmark
+  };
+}
+
+// History Management Function
+async function getHistory(params) {
+  const {
+    keywords = "",
+    start_date,
+    end_date,
+    domains = [],
+    min_visit_count = 1,
+    max_results = 50,
+    sort_by = "visit_time",
+    sort_order = "desc"
+  } = params;
+
   try {
-    // Use chrome.scripting.executeScript with a function instead of eval
-    const results = await chrome.scripting.executeScript({
-      target: { tabId: activeTab.id },
-      func: (codeToExecute) => {
-        // Execute code safely without eval
+    // Chrome History API search configuration
+    const searchQuery = {
+      text: keywords,
+      maxResults: Math.min(max_results * 3, 1000), // Over-fetch for filtering
+    };
+
+    // Add date range if specified
+    if (start_date) {
+      searchQuery.startTime = new Date(start_date).getTime();
+    }
+    if (end_date) {
+      searchQuery.endTime = new Date(end_date).getTime();
+    }
+
+    // Execute history search
+    const historyItems = await chrome.history.search(searchQuery);
+    
+    // Apply advanced filters
+    let filteredItems = historyItems.filter(item => {
+      // Domain filter
+      if (domains.length > 0) {
         try {
-          // Create a script element to bypass CSP
-          const script = document.createElement('script');
-          script.textContent = codeToExecute;
-          document.head.appendChild(script);
-          document.head.removeChild(script);
-          return { success: true, executed: true };
-        } catch (error) {
-          // Fallback: try to execute common operations directly
-          if (codeToExecute.includes('window.scrollTo')) {
-            const match = codeToExecute.match(/window\.scrollTo\((\d+),\s*(\d+|[^)]+)\)/);
-            if (match) {
-              const x = parseInt(match[1]);
-              const y = match[2].includes('document.body.scrollHeight') ? 
-                      document.body.scrollHeight / 2 : parseInt(match[2]);
-              window.scrollTo(x, y);
-              return { success: true, scrolled: true, x, y };
-            }
+          const itemDomain = new URL(item.url).hostname;
+          if (!domains.some(domain => itemDomain.includes(domain))) {
+            return false;
           }
-          
-          if (codeToExecute.includes('document.querySelector')) {
-            // Handle simple querySelector operations
-            const match = codeToExecute.match(/document\.querySelector\(['"]([^'"]+)['"]\)/);
-            if (match) {
-              const element = document.querySelector(match[1]);
-              return { success: true, element: element ? 'found' : 'not found', selector: match[1] };
-            }
-          }
-          
-          throw error;
+        } catch (e) {
+          // Skip items with invalid URLs
+          return false;
         }
-      },
-      args: [code],
+      }
+      
+      // Visit count filter
+      if (item.visitCount < min_visit_count) {
+        return false;
+      }
+      
+      return true;
     });
-    return results[0].result;
+
+    // Sort results
+    filteredItems.sort((a, b) => {
+      let aVal, bVal;
+      switch (sort_by) {
+        case "visit_count":
+          aVal = a.visitCount;
+          bVal = b.visitCount;
+          break;
+        case "title":
+          aVal = (a.title || "").toLowerCase();
+          bVal = (b.title || "").toLowerCase();
+          break;
+        default: // visit_time
+          aVal = a.lastVisitTime;
+          bVal = b.lastVisitTime;
+      }
+      
+      if (sort_order === "asc") {
+        return aVal > bVal ? 1 : -1;
+      } else {
+        return aVal < bVal ? 1 : -1;
+      }
+    });
+
+    // Limit results
+    const results = filteredItems.slice(0, max_results);
+    
+    // Format response with comprehensive metadata
+    return {
+      success: true,
+      history_items: results.map(item => {
+        let domain;
+        try {
+          domain = new URL(item.url).hostname;
+        } catch (e) {
+          domain = "invalid-url";
+        }
+        
+        return {
+          id: item.id,
+          url: item.url,
+          title: item.title || "Untitled",
+          last_visit_time: new Date(item.lastVisitTime).toISOString(),
+          visit_count: item.visitCount,
+          domain: domain,
+          typed_count: item.typedCount || 0
+        };
+      }),
+      metadata: {
+        total_found: filteredItems.length,
+        returned_count: results.length,
+        search_params: {
+          keywords: keywords || null,
+          date_range: start_date && end_date ?
+            `${start_date} to ${end_date}` :
+            start_date ? `from ${start_date}` :
+            end_date ? `until ${end_date}` : null,
+          domains: domains.length > 0 ? domains : null,
+          min_visit_count,
+          sort_by,
+          sort_order
+        },
+        execution_time: new Date().toISOString(),
+        over_fetched: historyItems.length,
+        filters_applied: {
+          domain_filter: domains.length > 0,
+          visit_count_filter: min_visit_count > 1,
+          date_filter: !!(start_date || end_date),
+          keyword_filter: !!keywords
+        }
+      }
+    };
+
   } catch (error) {
     return {
       success: false,
-      error: error.message,
-      note: "CSP restrictions prevent arbitrary JavaScript execution. Try using specific automation tools instead."
+      error: `History search failed: ${error.message}`,
+      history_items: [],
+      metadata: {
+        total_found: 0,
+        returned_count: 0,
+        search_params: params,
+        execution_time: new Date().toISOString()
+      }
+    };
+  }
+}
+
+// Selected Text Management Function
+async function getSelectedText(params) {
+  const {
+    include_metadata = true,
+    max_length = 10000
+  } = params;
+
+  try {
+    // Get the active tab
+    const [activeTab] = await chrome.tabs.query({
+      active: true,
+      currentWindow: true,
+    });
+    
+    if (!activeTab) {
+      return {
+        success: false,
+        error: "No active tab found",
+        selected_text: "",
+        metadata: {
+          execution_time: new Date().toISOString()
+        }
+      };
+    }
+
+    // Execute script to get selected text
+    const results = await chrome.scripting.executeScript({
+      target: { tabId: activeTab.id },
+      func: () => {
+        const selection = window.getSelection();
+        const selectedText = selection.toString();
+        
+        if (!selectedText) {
+          return {
+            text: "",
+            hasSelection: false,
+            metadata: null
+          };
+        }
+
+        // Get metadata about the selection
+        const range = selection.getRangeAt(0);
+        const rect = range.getBoundingClientRect();
+        
+        // Get parent element info
+        const commonAncestor = range.commonAncestorContainer;
+        const parentElement = commonAncestor.nodeType === Node.TEXT_NODE
+          ? commonAncestor.parentElement
+          : commonAncestor;
+        
+        const metadata = {
+          length: selectedText.length,
+          word_count: selectedText.trim().split(/\s+/).filter(word => word.length > 0).length,
+          line_count: selectedText.split('\n').length,
+          position: {
+            x: rect.x,
+            y: rect.y,
+            width: rect.width,
+            height: rect.height
+          },
+          parent_element: {
+            tag_name: parentElement.tagName?.toLowerCase(),
+            class_name: parentElement.className,
+            id: parentElement.id,
+            text_content_length: parentElement.textContent?.length || 0
+          },
+          page_info: {
+            url: window.location.href,
+            title: document.title,
+            domain: window.location.hostname
+          },
+          selection_info: {
+            anchor_offset: selection.anchorOffset,
+            focus_offset: selection.focusOffset,
+            range_count: selection.rangeCount,
+            is_collapsed: selection.isCollapsed
+          }
+        };
+
+        return {
+          text: selectedText,
+          hasSelection: true,
+          metadata: metadata
+        };
+      }
+    });
+
+    const result = results[0]?.result;
+    
+    if (!result) {
+      return {
+        success: false,
+        error: "Failed to execute selection script",
+        selected_text: "",
+        metadata: {
+          execution_time: new Date().toISOString()
+        }
+      };
+    }
+
+    if (!result.hasSelection) {
+      return {
+        success: true,
+        selected_text: "",
+        has_selection: false,
+        message: "No text is currently selected on the page",
+        metadata: {
+          execution_time: new Date().toISOString(),
+          tab_info: {
+            id: activeTab.id,
+            url: activeTab.url,
+            title: activeTab.title
+          }
+        }
+      };
+    }
+
+    // Truncate text if it exceeds max_length
+    let selectedText = result.text;
+    let truncated = false;
+    if (selectedText.length > max_length) {
+      selectedText = selectedText.substring(0, max_length);
+      truncated = true;
+    }
+
+    const response = {
+      success: true,
+      selected_text: selectedText,
+      has_selection: true,
+      character_count: result.text.length,
+      truncated: truncated,
+      metadata: {
+        execution_time: new Date().toISOString(),
+        tab_info: {
+          id: activeTab.id,
+          url: activeTab.url,
+          title: activeTab.title
+        }
+      }
+    };
+
+    // Include detailed metadata if requested
+    if (include_metadata && result.metadata) {
+      response.selection_metadata = result.metadata;
+    }
+
+    return response;
+
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to get selected text: ${error.message}`,
+      selected_text: "",
+      has_selection: false,
+      metadata: {
+        execution_time: new Date().toISOString(),
+        error_details: error.stack
+      }
     };
   }
 }
@@ -493,6 +1146,12 @@ chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
     sendResponse({
       connected: mcpSocket && mcpSocket.readyState === WebSocket.OPEN,
     });
+  } else if (request.action === "getToolCount") {
+    const tools = getAvailableTools();
+    sendResponse({
+      toolCount: tools.length,
+      tools: tools.map(t => t.name)
+    });
   } else if (request.action === "reconnect") {
     connectToMCPServer();
     sendResponse({ success: true });
@@ -503,4 +1162,4 @@ chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
     sendResponse({ success: true });
   }
   return true; // Keep the message channel open
-});
+});