kernelbot 1.0.26 → 1.0.28

package/src/tools/browser.js

@@ -10,8 +10,8 @@ const MAX_CONTENT_LENGTH = 15000;
 const MAX_SCREENSHOT_WIDTH = 1920;
 const MAX_SCREENSHOT_HEIGHT = 1080;
 const SCREENSHOTS_DIR = join(homedir(), '.kernelbot', 'screenshots');
+const SESSION_TTL = 60_000; // 1 minute of inactivity — Chrome is a RAM hog
 
-// Blocklist to prevent abuse — internal/private network ranges and sensitive targets
 const BLOCKED_URL_PATTERNS = [
   /^https?:\/\/localhost/i,
   /^https?:\/\/127\./,
@@ -26,6 +26,118 @@ const BLOCKED_URL_PATTERNS = [
   /^data:/i,
 ];
 
+const BROWSER_ARGS = [
+  '--no-sandbox',
+  '--disable-setuid-sandbox',
+  '--disable-dev-shm-usage',
+  '--disable-gpu',
+  '--disable-extensions',
+  '--disable-background-networking',
+  '--disable-default-apps',
+  '--disable-sync',
+  '--no-first-run',
+];
+
+// ── Persistent Browser Session ──────────────────────────────────────────────
+
+let _browser = null;
+const _pages = new Map(); // sessionId → page (per-worker isolation)
+let _sessionTimer = null;
+
+async function ensureBrowser() {
+  if (_browser && _browser.connected) return _browser;
+  // Old browser died — clean up all session pages
+  _pages.clear();
+  _browser = await puppeteer.launch({ headless: true, args: BROWSER_ARGS });
+  return _browser;
+}
+
+function resetSessionTimer() {
+  if (_sessionTimer) clearTimeout(_sessionTimer);
+  _sessionTimer = setTimeout(() => closeBrowserSession(), SESSION_TTL);
+}
+
+async function closeBrowserSession() {
+  if (_sessionTimer) { clearTimeout(_sessionTimer); _sessionTimer = null; }
+  // Close all session pages
+  for (const [id, page] of _pages) {
+    await page.close().catch(() => {});
+  }
+  _pages.clear();
+  if (_browser) {
+    await _browser.close().catch(() => {});
+    _browser = null;
+  }
+}
+
+/**
+ * Close a specific session's page. Called when a worker finishes.
+ * If no sessions remain, close the entire browser to free RAM/CPU.
+ */
+export async function closeSession(sessionId) {
+  const page = _pages.get(sessionId);
+  if (page) {
+    _pages.delete(sessionId);
+    await page.close().catch(() => {});
+  }
+  // If no more sessions, kill the browser entirely to free resources
+  if (_pages.size === 0 && _browser) {
+    await closeBrowserSession();
+  }
+}
+
+async function setupPage(page) {
+  await page.setUserAgent(
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+  );
+  await page.setViewport({ width: MAX_SCREENSHOT_WIDTH, height: MAX_SCREENSHOT_HEIGHT });
+}
+
+/**
+ * Get the persistent page for a session. If url is provided and differs from
+ * the current page URL, navigate to it. Each session (worker) gets its own tab.
+ */
+async function getMainPage(url, sessionId = 'default') {
+  resetSessionTimer();
+  const browser = await ensureBrowser();
+
+  const existing = _pages.get(sessionId);
+  if (existing) {
+    try {
+      await existing.title(); // probe — throws if page closed/crashed
+      if (url) {
+        const current = existing.url();
+        if (current !== url) {
+          await existing.goto(url, { waitUntil: 'networkidle2', timeout: NAVIGATION_TIMEOUT });
+        }
+      }
+      return existing;
+    } catch {
+      // Page is stale, recreate
+      _pages.delete(sessionId);
+    }
+  }
+
+  const page = await browser.newPage();
+  await setupPage(page);
+  _pages.set(sessionId, page);
+  if (url) {
+    await page.goto(url, { waitUntil: 'networkidle2', timeout: NAVIGATION_TIMEOUT });
+  }
+  return page;
+}
+
+/**
+ * Get a temporary page (for web_search). Auto-closed by caller.
+ */
+async function getTempPage() {
+  resetSessionTimer();
+  const browser = await ensureBrowser();
+  const page = await browser.newPage();
+  await setupPage(page);
+  return page;
+}
+
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
 function validateUrl(url) {
@@ -33,14 +145,12 @@ function validateUrl(url) {
     return { valid: false, error: 'URL is required' };
   }
 
-  // Block non-http protocols before auto-prepending https
   for (const pattern of BLOCKED_URL_PATTERNS) {
     if (pattern.test(url)) {
       return { valid: false, error: 'Access to internal/private network addresses or non-HTTP protocols is blocked' };
     }
   }
 
-  // Add https:// if no protocol specified
   if (!/^https?:\/\//i.test(url)) {
     url = 'https://' + url;
   }
@@ -51,7 +161,6 @@ function validateUrl(url) {
     return { valid: false, error: 'Invalid URL format' };
   }
 
-  // Check again after normalization (e.g., localhost without protocol)
   for (const pattern of BLOCKED_URL_PATTERNS) {
     if (pattern.test(url)) {
       return { valid: false, error: 'Access to internal/private network addresses is blocked' };
@@ -70,49 +179,90 @@ async function ensureScreenshotsDir() {
   await mkdir(SCREENSHOTS_DIR, { recursive: true });
 }
 
-async function withBrowser(fn) {
-  let browser;
-  try {
-    browser = await puppeteer.launch({
-      headless: true,
-      args: [
-        '--no-sandbox',
-        '--disable-setuid-sandbox',
-        '--disable-dev-shm-usage',
-        '--disable-gpu',
-        '--disable-extensions',
-        '--disable-background-networking',
-        '--disable-default-apps',
-        '--disable-sync',
-        '--no-first-run',
-      ],
-    });
-    return await fn(browser);
-  } finally {
-    if (browser) {
-      await browser.close().catch(() => {});
-    }
+function handleNavError(err, url) {
+  if (err.message.includes('net::ERR_NAME_NOT_RESOLVED')) {
+    return { error: `Could not resolve hostname for: ${url}` };
+  }
+  if (err.message.includes('Timeout')) {
+    return { error: `Page load timed out after ${NAVIGATION_TIMEOUT / 1000}s: ${url}` };
   }
+  return { error: `Navigation failed: ${err.message}` };
 }
 
-async function navigateTo(page, url, waitUntil = 'networkidle2') {
-  await page.setUserAgent(
-    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
-  );
-  await page.setViewport({ width: MAX_SCREENSHOT_WIDTH, height: MAX_SCREENSHOT_HEIGHT });
-  await page.goto(url, {
-    waitUntil,
-    timeout: NAVIGATION_TIMEOUT,
+/** Extract page content + links from a page. */
+async function extractPageContent(page) {
+  return page.evaluate(() => {
+    const title = document.title || '';
+    const metaDesc = document.querySelector('meta[name="description"]')?.content || '';
+    const canonicalUrl = document.querySelector('link[rel="canonical"]')?.href || window.location.href;
+
+    const headings = [];
+    for (const tag of ['h1', 'h2', 'h3']) {
+      document.querySelectorAll(tag).forEach((el) => {
+        const text = el.textContent.trim();
+        if (text) headings.push({ level: tag, text });
+      });
+    }
+
+    const contentSelectors = [
+      'article', 'main', '[role="main"]',
+      '.content', '.article', '.post',
+      '#content', '#main', '#article',
+    ];
+
+    let mainText = '';
+    for (const sel of contentSelectors) {
+      const el = document.querySelector(sel);
+      if (el) { mainText = el.innerText.trim(); break; }
+    }
+
+    if (!mainText) {
+      const clone = document.body.cloneNode(true);
+      for (const el of clone.querySelectorAll('script, style, nav, footer, header, aside, [role="navigation"]')) {
+        el.remove();
+      }
+      mainText = clone.innerText.trim();
+    }
+
+    const links = [];
+    document.querySelectorAll('a[href]').forEach((a) => {
+      const text = a.textContent.trim();
+      const href = a.href;
+      if (text && href && !href.startsWith('javascript:')) {
+        links.push({ text: text.slice(0, 100), href });
+      }
+    });
+
+    return { title, metaDesc, canonicalUrl, headings, mainText, links: links.slice(0, 50) };
   });
 }
 
 // ── Tool Definitions ─────────────────────────────────────────────────────────
 
 export const definitions = [
+  {
+    name: 'web_search',
+    description:
+      'Search the web using DuckDuckGo and return a list of results with titles, snippets, and URLs. Use this FIRST when asked to search, find, or look up anything on the web. Then use browse_website to visit specific result URLs for details.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        query: {
+          type: 'string',
+          description: 'The search query (e.g., "top cars haraj market", "best restaurants in dubai")',
+        },
+        num_results: {
+          type: 'number',
+          description: 'Number of results to return (default: 8, max: 20)',
+        },
+      },
+      required: ['query'],
+    },
+  },
   {
     name: 'browse_website',
     description:
-      'Navigate to a website URL and extract its content including title, headings, text, links, and metadata. Returns a structured summary of the page. Handles JavaScript-rendered pages.',
+      'Navigate to a URL and extract its content, headings, and links. The page stays open — subsequent calls to interact_with_page or extract_content reuse it instantly without reloading. Always returns navigation links so you can browse deeper.',
     input_schema: {
       type: 'object',
       properties: {
@@ -124,10 +274,6 @@ export const definitions = [
           type: 'string',
           description: 'Optional CSS selector to wait for before extracting content (useful for JS-heavy pages)',
         },
-        include_links: {
-          type: 'boolean',
-          description: 'Include links found on the page (default: false)',
-        },
       },
       required: ['url'],
     },
@@ -135,7 +281,7 @@ export const definitions = [
   {
     name: 'screenshot_website',
     description:
-      'Take a screenshot of a website and save it to disk. Returns the file path to the screenshot image. Supports full-page and viewport-only screenshots.',
+      'Take a screenshot of a website (or the current open page) and send it to chat. Reuses the open page if the URL matches.',
     input_schema: {
       type: 'object',
       properties: {
@@ -158,13 +304,13 @@ export const definitions = [
   {
     name: 'extract_content',
     description:
-      'Extract specific content from a webpage using CSS selectors. Returns the text or HTML content of matched elements. Useful for scraping structured data.',
+      'Extract specific content from the current page (or a new URL) using CSS selectors. Reuses the open page if URL matches. Great for pulling structured data like listings, prices, or tables.',
     input_schema: {
       type: 'object',
       properties: {
         url: {
           type: 'string',
-          description: 'The URL to extract content from',
+          description: 'The URL to extract content from (optional if a page is already open)',
         },
         selector: {
           type: 'string',
@@ -183,7 +329,7 @@ export const definitions = [
           description: 'Maximum number of elements to return (default: 20)',
         },
       },
-      required: ['url', 'selector'],
+      required: ['selector'],
     },
   },
   {
@@ -208,13 +354,13 @@ export const definitions = [
   {
     name: 'interact_with_page',
     description:
-      'Interact with a webpage by clicking elements, typing into inputs, scrolling, or executing JavaScript. Returns the page state after interaction.',
+      'Interact with the currently open page (or a new URL) — click elements, type into inputs, scroll, or run JS. The page stays open so you can chain multiple interactions. If no URL is given, operates on the page already open from browse_website. Returns page content after actions complete.',
     input_schema: {
       type: 'object',
       properties: {
         url: {
           type: 'string',
-          description: 'The URL to interact with',
+          description: 'URL to navigate to before interacting. Optional — omit to use the currently open page.',
         },
         actions: {
           type: 'array',
@@ -262,111 +408,103 @@ export const definitions = [
           description: 'Extract page content after performing actions (default: true)',
         },
       },
-      required: ['url', 'actions'],
+      required: ['actions'],
     },
   },
 ];
 
 // ── Handlers ─────────────────────────────────────────────────────────────────
 
-async function handleBrowse(params) {
-  const validation = validateUrl(params.url);
-  if (!validation.valid) return { error: validation.error };
+async function handleWebSearch(params) {
+  if (!params.query || typeof params.query !== 'string') {
+    return { error: 'query is required' };
+  }
 
-  const url = validation.url;
+  const numResults = Math.min(params.num_results || 8, 20);
+  const searchUrl = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(params.query)}`;
 
-  return withBrowser(async (browser) => {
-    const page = await browser.newPage();
+  let page;
+  try {
+    page = await getTempPage();
+    await page.goto(searchUrl, { waitUntil: 'domcontentloaded', timeout: NAVIGATION_TIMEOUT });
+  } catch (err) {
+    if (page) await page.close().catch(() => {});
+    return { error: `Search failed: ${err.message}` };
+  }
 
-    try {
-      await navigateTo(page, url);
-    } catch (err) {
-      if (err.message.includes('net::ERR_NAME_NOT_RESOLVED')) {
-        return { error: `Could not resolve hostname for: ${url}` };
-      }
-      if (err.message.includes('Timeout')) {
-        return { error: `Page load timed out after ${NAVIGATION_TIMEOUT / 1000}s: ${url}` };
+  try {
+    const results = await page.evaluate((maxResults) => {
+      const items = [];
+      const resultElements = document.querySelectorAll('.result');
+      for (let i = 0; i < Math.min(resultElements.length, maxResults); i++) {
+        const el = resultElements[i];
+        const titleEl = el.querySelector('.result__title a, .result__a');
+        const snippetEl = el.querySelector('.result__snippet');
+        const urlEl = el.querySelector('.result__url');
+
+        if (titleEl) {
+          items.push({
+            title: titleEl.textContent.trim(),
+            url: titleEl.href || '',
+            snippet: snippetEl ? snippetEl.textContent.trim() : '',
+            displayed_url: urlEl ? urlEl.textContent.trim() : '',
+          });
+        }
       }
-      return { error: `Navigation failed: ${err.message}` };
-    }
+      return items;
+    }, numResults);
 
-    // Wait for optional selector
-    if (params.wait_for_selector) {
-      try {
-        await page.waitForSelector(params.wait_for_selector, { timeout: 10000 });
-      } catch {
-        // Continue even if selector not found
-      }
+    if (results.length === 0) {
+      return { success: true, query: params.query, results: [], message: 'No results found' };
     }
 
-    const content = await page.evaluate((includeLinks) => {
-      const title = document.title || '';
-      const metaDesc = document.querySelector('meta[name="description"]')?.content || '';
-      const canonicalUrl = document.querySelector('link[rel="canonical"]')?.href || window.location.href;
-
-      // Extract headings
-      const headings = [];
-      for (const tag of ['h1', 'h2', 'h3']) {
-        document.querySelectorAll(tag).forEach((el) => {
-          const text = el.textContent.trim();
-          if (text) headings.push({ level: tag, text });
-        });
-      }
+    return { success: true, query: params.query, result_count: results.length, results };
+  } finally {
+    await page.close().catch(() => {});
+  }
+}
 
-      // Extract main text content
-      // Prefer common article/content containers
-      const contentSelectors = [
-        'article', 'main', '[role="main"]',
-        '.content', '.article', '.post',
-        '#content', '#main', '#article',
-      ];
-
-      let mainText = '';
-      for (const sel of contentSelectors) {
-        const el = document.querySelector(sel);
-        if (el) {
-          mainText = el.innerText.trim();
-          break;
-        }
-      }
+async function handleBrowse(params, context) {
+  const validation = validateUrl(params.url);
+  if (!validation.valid) return { error: validation.error };
 
-      // Fall back to body text if no content container found
-      if (!mainText) {
-        // Remove script, style, nav, footer, header noise
-        const clone = document.body.cloneNode(true);
-        for (const el of clone.querySelectorAll('script, style, nav, footer, header, aside, [role="navigation"]')) {
-          el.remove();
-        }
-        mainText = clone.innerText.trim();
-      }
+  const url = validation.url;
+  const sessionId = context?.sessionId || 'default';
+  let page;
 
-      // Extract links if requested
-      let links = [];
-      if (includeLinks) {
-        document.querySelectorAll('a[href]').forEach((a) => {
-          const text = a.textContent.trim();
-          const href = a.href;
-          if (text && href && !href.startsWith('javascript:')) {
-            links.push({ text: text.slice(0, 100), href });
-          }
-        });
-        links = links.slice(0, 50);
-      }
+  try {
+    page = await getMainPage(url, sessionId);
+  } catch (err) {
+    return handleNavError(err, url);
+  }
 
-      return { title, metaDesc, canonicalUrl, headings, mainText, links };
-    }, params.include_links || false);
+  if (params.wait_for_selector) {
+    try {
+      await page.waitForSelector(params.wait_for_selector, { timeout: 10000 });
+    } catch {
+      // Continue even if selector not found
+    }
+  }
 
-    return {
-      success: true,
-      url: page.url(),
-      title: content.title,
-      meta_description: content.metaDesc,
-      canonical_url: content.canonicalUrl,
-      headings: content.headings.slice(0, 30),
-      content: truncate(content.mainText),
-      links: content.links || [],
-    };
-  });
+  const content = await extractPageContent(page);
+
+  const result = {
+    success: true,
+    url: page.url(),
+    title: content.title,
+    meta_description: content.metaDesc,
+    canonical_url: content.canonicalUrl,
+    headings: content.headings.slice(0, 30),
+    content: truncate(content.mainText),
+    links: content.links || [],
+  };
+
+  // Nudge the model to navigate deeper when links are available
+  if (content.links.length > 0) {
+    result._next = 'Page is open. Use interact_with_page (no URL needed) to click links or type in search boxes, then read the results.';
+  }
+
+  return result;
 }
 
 async function handleScreenshot(params, context) {
@@ -374,157 +512,148 @@ async function handleScreenshot(params, context) {
   if (!validation.valid) return { error: validation.error };
 
   const url = validation.url;
+  const sessionId = context?.sessionId || 'default';
   await ensureScreenshotsDir();
 
-  return withBrowser(async (browser) => {
-    const page = await browser.newPage();
-
-    try {
-      await navigateTo(page, url);
-    } catch (err) {
-      if (err.message.includes('net::ERR_NAME_NOT_RESOLVED')) {
-        return { error: `Could not resolve hostname for: ${url}` };
-      }
-      if (err.message.includes('Timeout')) {
-        return { error: `Page load timed out after ${NAVIGATION_TIMEOUT / 1000}s: ${url}` };
-      }
-      return { error: `Navigation failed: ${err.message}` };
-    }
+  let page;
+  try {
+    page = await getMainPage(url, sessionId);
+  } catch (err) {
+    return handleNavError(err, url);
+  }
 
-    const timestamp = Date.now();
-    const safeName = new URL(url).hostname.replace(/[^a-z0-9.-]/gi, '_');
-    const filename = `${safeName}_${timestamp}.png`;
-    const filepath = join(SCREENSHOTS_DIR, filename);
+  const timestamp = Date.now();
+  const safeName = new URL(url).hostname.replace(/[^a-z0-9.-]/gi, '_');
+  const filename = `${safeName}_${timestamp}.png`;
+  const filepath = join(SCREENSHOTS_DIR, filename);
 
-    const screenshotOptions = {
-      path: filepath,
-      type: 'png',
-    };
+  const screenshotOptions = { path: filepath, type: 'png' };
 
-    if (params.selector) {
-      try {
-        const element = await page.$(params.selector);
-        if (!element) {
-          return { error: `Element not found for selector: ${params.selector}` };
-        }
-        await element.screenshot(screenshotOptions);
-      } catch (err) {
-        return { error: `Failed to screenshot element: ${err.message}` };
+  if (params.selector) {
+    try {
+      const element = await page.$(params.selector);
+      if (!element) {
+        return { error: `Element not found for selector: ${params.selector}` };
       }
-    } else {
-      screenshotOptions.fullPage = params.full_page || false;
-      await page.screenshot(screenshotOptions);
+      await element.screenshot(screenshotOptions);
+    } catch (err) {
+      return { error: `Failed to screenshot element: ${err.message}` };
     }
+  } else {
+    screenshotOptions.fullPage = params.full_page || false;
+    await page.screenshot(screenshotOptions);
+  }
 
-    const title = await page.title();
+  const title = await page.title();
 
-    // Send the screenshot directly to Telegram chat
-    if (context?.sendPhoto) {
-      try {
-        await context.sendPhoto(filepath, `📸 ${title || url}`);
-      } catch {
-        // Photo sending is best-effort; don't fail the tool
-      }
+  if (context?.sendPhoto) {
+    try {
+      await context.sendPhoto(filepath, `📸 ${title || url}`);
+    } catch {
+      // Photo sending is best-effort
     }
+  }
 
-    return {
-      success: true,
-      url: page.url(),
-      title,
-      screenshot_path: filepath,
-      filename,
-      sent_to_chat: !!context?.sendPhoto,
-    };
-  });
+  return {
+    success: true,
+    url: page.url(),
+    title,
+    screenshot_path: filepath,
+    filename,
+    sent_to_chat: !!context?.sendPhoto,
+  };
 }
 
-async function handleExtract(params) {
-  const validation = validateUrl(params.url);
-  if (!validation.valid) return { error: validation.error };
+async function handleExtract(params, context) {
+  // URL is optional — if not given, use the current open page
+  let url = null;
+  if (params.url) {
+    const validation = validateUrl(params.url);
+    if (!validation.valid) return { error: validation.error };
+    url = validation.url;
+  }
 
-  const url = validation.url;
+  const sessionId = context?.sessionId || 'default';
   const limit = Math.min(params.limit || 20, 100);
 
-  return withBrowser(async (browser) => {
-    const page = await browser.newPage();
-
-    try {
-      await navigateTo(page, url);
-    } catch (err) {
-      if (err.message.includes('net::ERR_NAME_NOT_RESOLVED')) {
-        return { error: `Could not resolve hostname for: ${url}` };
-      }
-      if (err.message.includes('Timeout')) {
-        return { error: `Page load timed out after ${NAVIGATION_TIMEOUT / 1000}s: ${url}` };
-      }
-      return { error: `Navigation failed: ${err.message}` };
-    }
+  let page;
+  try {
+    page = await getMainPage(url, sessionId);
+  } catch (err) {
+    return handleNavError(err, url);
+  }
 
-    const results = await page.evaluate(
-      (selector, attribute, includeHtml, maxItems) => {
-        const elements = document.querySelectorAll(selector);
-        if (elements.length === 0) return { found: 0, items: [] };
+  // If no URL and no page was open, we can't extract
+  if (!url && page.url() === 'about:blank') {
+    return { error: 'No page is currently open. Provide a URL or use browse_website first.' };
+  }
 
-        const items = [];
-        for (let i = 0; i < Math.min(elements.length, maxItems); i++) {
-          const el = elements[i];
-          const item = {};
+  const results = await page.evaluate(
+    (selector, attribute, includeHtml, maxItems) => {
+      const elements = document.querySelectorAll(selector);
+      if (elements.length === 0) return { found: 0, items: [] };
 
-          if (attribute) {
-            item.value = el.getAttribute(attribute) || null;
-          } else {
-            item.text = el.innerText?.trim() || el.textContent?.trim() || '';
-          }
+      const items = [];
+      for (let i = 0; i < Math.min(elements.length, maxItems); i++) {
+        const el = elements[i];
+        const item = {};
 
-          if (includeHtml) {
-            item.html = el.outerHTML;
-          }
+        if (attribute) {
+          item.value = el.getAttribute(attribute) || null;
+        } else {
+          item.text = el.innerText?.trim() || el.textContent?.trim() || '';
+        }
 
-          item.tag = el.tagName.toLowerCase();
-          items.push(item);
+        if (includeHtml) {
+          item.html = el.outerHTML;
         }
 
-        return { found: elements.length, items };
-      },
-      params.selector,
-      params.attribute || null,
-      params.include_html || false,
-      limit
-    );
-
-    if (results.found === 0) {
-      return {
-        success: true,
-        url: page.url(),
-        selector: params.selector,
-        found: 0,
-        items: [],
-        message: `No elements found matching selector: ${params.selector}`,
-      };
-    }
+        item.tag = el.tagName.toLowerCase();
+        items.push(item);
+      }
 
-    // Truncate individual items to prevent massive responses
-    for (const item of results.items) {
-      if (item.text) item.text = truncate(item.text, 2000);
-      if (item.html) item.html = truncate(item.html, 3000);
-    }
+      return { found: elements.length, items };
+    },
+    params.selector,
+    params.attribute || null,
+    params.include_html || false,
+    limit,
+  );
 
+  if (results.found === 0) {
     return {
       success: true,
       url: page.url(),
       selector: params.selector,
-      found: results.found,
-      returned: results.items.length,
-      items: results.items,
+      found: 0,
+      items: [],
+      message: `No elements found matching selector: ${params.selector}`,
     };
-  });
-}
+  }
 
-async function handleInteract(params) {
-  const validation = validateUrl(params.url);
-  if (!validation.valid) return { error: validation.error };
+  for (const item of results.items) {
+    if (item.text) item.text = truncate(item.text, 2000);
+    if (item.html) item.html = truncate(item.html, 3000);
+  }
 
-  const url = validation.url;
+  return {
+    success: true,
+    url: page.url(),
+    selector: params.selector,
+    found: results.found,
+    returned: results.items.length,
+    items: results.items,
+  };
+}
+
+async function handleInteract(params, context) {
+  // URL is optional — if not given, use the current open page
+  let url = null;
+  if (params.url) {
+    const validation = validateUrl(params.url);
+    if (!validation.valid) return { error: validation.error };
+    url = validation.url;
+  }
 
   if (!params.actions || params.actions.length === 0) {
     return { error: 'At least one action is required' };
@@ -534,7 +663,6 @@ async function handleInteract(params) {
     return { error: 'Maximum 10 actions per request' };
   }
 
-  // Block dangerous evaluate scripts
   for (const action of params.actions) {
     if (action.type === 'evaluate' && action.script) {
       const blocked = /fetch\s*\(|XMLHttpRequest|window\.location\s*=|document\.cookie|localStorage|sessionStorage/i;
@@ -544,105 +672,100 @@ async function handleInteract(params) {
     }
   }
 
-  return withBrowser(async (browser) => {
-    const page = await browser.newPage();
+  const sessionId = context?.sessionId || 'default';
+  let page;
+  try {
+    page = await getMainPage(url, sessionId);
+  } catch (err) {
+    return handleNavError(err, url);
+  }
 
-    try {
-      await navigateTo(page, url);
-    } catch (err) {
-      if (err.message.includes('net::ERR_NAME_NOT_RESOLVED')) {
-        return { error: `Could not resolve hostname for: ${url}` };
-      }
-      if (err.message.includes('Timeout')) {
-        return { error: `Page load timed out after ${NAVIGATION_TIMEOUT / 1000}s: ${url}` };
-      }
-      return { error: `Navigation failed: ${err.message}` };
-    }
+  if (!url && page.url() === 'about:blank') {
+    return { error: 'No page is currently open. Provide a URL or use browse_website first.' };
+  }
 
-    const actionResults = [];
-
-    for (const action of params.actions) {
-      try {
-        switch (action.type) {
-          case 'click': {
-            if (!action.selector) {
-              actionResults.push({ action: 'click', error: 'selector is required' });
-              break;
-            }
-            await page.waitForSelector(action.selector, { timeout: 5000 });
-            await page.click(action.selector);
-            // Brief wait for any navigation or rendering
-            await new Promise((r) => setTimeout(r, 500));
-            actionResults.push({ action: 'click', selector: action.selector, success: true });
-            break;
-          }
+  const actionResults = [];
 
-          case 'type': {
-            if (!action.selector || !action.text) {
-              actionResults.push({ action: 'type', error: 'selector and text are required' });
-              break;
-            }
-            await page.waitForSelector(action.selector, { timeout: 5000 });
-            await page.type(action.selector, action.text);
-            actionResults.push({ action: 'type', selector: action.selector, success: true });
+  for (const action of params.actions) {
+    try {
+      switch (action.type) {
+        case 'click': {
+          if (!action.selector) {
+            actionResults.push({ action: 'click', error: 'selector is required' });
             break;
           }
+          await page.waitForSelector(action.selector, { timeout: 5000 });
+          await page.click(action.selector);
+          // Wait for navigation or rendering to settle
+          await page.waitForNetworkIdle({ timeout: 5000 }).catch(() => {});
+          actionResults.push({ action: 'click', selector: action.selector, success: true, navigated_to: page.url() });
+          break;
+        }
 
-          case 'scroll': {
-            const direction = action.direction || 'down';
-            const pixels = Math.min(action.pixels || 500, 5000);
-            const scrollAmount = direction === 'up' ? -pixels : pixels;
-            await page.evaluate((amount) => window.scrollBy(0, amount), scrollAmount);
-            actionResults.push({ action: 'scroll', direction, pixels, success: true });
+        case 'type': {
+          if (!action.selector || !action.text) {
+            actionResults.push({ action: 'type', error: 'selector and text are required' });
             break;
           }
+          await page.waitForSelector(action.selector, { timeout: 5000 });
+          await page.type(action.selector, action.text);
+          actionResults.push({ action: 'type', selector: action.selector, success: true });
+          break;
+        }
 
-          case 'wait': {
-            const ms = Math.min(action.milliseconds || 1000, 10000);
-            await new Promise((r) => setTimeout(r, ms));
-            actionResults.push({ action: 'wait', milliseconds: ms, success: true });
-            break;
-          }
+        case 'scroll': {
+          const direction = action.direction || 'down';
+          const pixels = Math.min(action.pixels || 500, 5000);
+          const scrollAmount = direction === 'up' ? -pixels : pixels;
+          await page.evaluate((amount) => window.scrollBy(0, amount), scrollAmount);
+          actionResults.push({ action: 'scroll', direction, pixels, success: true });
+          break;
+        }
 
-          case 'evaluate': {
-            if (!action.script) {
-              actionResults.push({ action: 'evaluate', error: 'script is required' });
-              break;
-            }
-            const result = await page.evaluate(action.script);
-            actionResults.push({ action: 'evaluate', success: true, result: String(result).slice(0, 2000) });
+        case 'wait': {
+          const ms = Math.min(action.milliseconds || 1000, 10000);
+          await new Promise((r) => setTimeout(r, ms));
+          actionResults.push({ action: 'wait', milliseconds: ms, success: true });
+          break;
+        }
+
+        case 'evaluate': {
+          if (!action.script) {
+            actionResults.push({ action: 'evaluate', error: 'script is required' });
             break;
           }
-
-          default:
-            actionResults.push({ action: action.type, error: `Unknown action type: ${action.type}` });
+          const result = await page.evaluate(action.script);
+          actionResults.push({ action: 'evaluate', success: true, result: String(result).slice(0, 2000) });
+          break;
         }
-      } catch (err) {
-        actionResults.push({ action: action.type, error: err.message });
+
+        default:
+          actionResults.push({ action: action.type, error: `Unknown action type: ${action.type}` });
       }
+    } catch (err) {
+      actionResults.push({ action: action.type, error: err.message });
     }
+  }
 
-    const response = {
-      success: true,
-      url: page.url(),
-      title: await page.title(),
-      actions: actionResults,
-    };
-
-    // Extract content after interactions unless disabled
-    if (params.extract_after !== false) {
-      const text = await page.evaluate(() => {
-        const clone = document.body.cloneNode(true);
-        for (const el of clone.querySelectorAll('script, style, nav, footer, header')) {
-          el.remove();
-        }
-        return clone.innerText.trim();
-      });
-      response.content = truncate(text);
-    }
+  const response = {
+    success: true,
+    url: page.url(),
+    title: await page.title(),
+    actions: actionResults,
+  };
+
+  if (params.extract_after !== false) {
+    const text = await page.evaluate(() => {
+      const clone = document.body.cloneNode(true);
+      for (const el of clone.querySelectorAll('script, style, nav, footer, header')) {
+        el.remove();
+      }
+      return clone.innerText.trim();
+    });
+    response.content = truncate(text);
+  }
 
-    return response;
-  });
+  return response;
 }
 
 async function handleSendImage(params, context) {
@@ -650,7 +773,6 @@ async function handleSendImage(params, context) {
     return { error: 'file_path is required' };
   }
 
-  // Verify the file exists
   try {
     await access(params.file_path);
   } catch {
@@ -672,6 +794,7 @@ async function handleSendImage(params, context) {
 // ── Export ────────────────────────────────────────────────────────────────────
 
 export const handlers = {
+  web_search: handleWebSearch,
   browse_website: handleBrowse,
   screenshot_website: handleScreenshot,
   extract_content: handleExtract,