@projectservan8n/cnapse 0.8.2 → 0.9.0

package/src/services/browser.ts

@@ -1,193 +1,157 @@
 /**
- * Browser Service - Playwright-based web automation
+ * Browser Service - Shell-based URL opening + Computer Control
  *
- * Provides reliable browser automation for:
- * - Web searches
- * - AI chat interactions (Perplexity, ChatGPT, Claude, etc.)
- * - Email (Gmail, Outlook)
- * - Google Sheets/Docs
- * - General web browsing
+ * Opens URLs in the user's default browser using system commands.
+ * All browser automation is done via mouse/keyboard control (nut-js).
  *
- * Uses your system Chrome with existing logins and profile!
+ * NO Playwright dependency - just native OS commands + desktop automation.
  */
 
-import { chromium, Browser, Page, BrowserContext } from 'playwright';
-import * as path from 'path';
-import * as os from 'os';
-import * as fs from 'fs';
-
-// Singleton browser instance
-let browser: Browser | null = null;
-let context: BrowserContext | null = null;
-let activePage: Page | null = null;
-
-// Browser configuration
-interface BrowserConfig {
-  headless: boolean;
-  slowMo: number;
-  viewport: { width: number; height: number };
-  useSystemBrowser: boolean;  // Use system Chrome with your profile
-}
-
-const defaultConfig: BrowserConfig = {
-  headless: false, // Show browser so user can see what's happening
-  slowMo: 50,      // Slight delay for visibility
-  viewport: { width: 1280, height: 800 },
-  useSystemBrowser: true  // Default to using system Chrome
-};
+import { runCommand } from '../tools/shell.js';
+import * as computer from '../tools/computer.js';
+import { describeScreen, captureScreenshot } from '../lib/vision.js';
 
 /**
- * Find Chrome/Edge executable on Windows
+ * Sleep helper
  */
-function findSystemBrowser(): string | null {
-  const possiblePaths = [
-    // Chrome paths
-    path.join(process.env['PROGRAMFILES'] || '', 'Google', 'Chrome', 'Application', 'chrome.exe'),
-    path.join(process.env['PROGRAMFILES(X86)'] || '', 'Google', 'Chrome', 'Application', 'chrome.exe'),
-    path.join(process.env['LOCALAPPDATA'] || '', 'Google', 'Chrome', 'Application', 'chrome.exe'),
-    // Edge paths (fallback)
-    path.join(process.env['PROGRAMFILES'] || '', 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
-    path.join(process.env['PROGRAMFILES(X86)'] || '', 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
-  ];
-
-  for (const browserPath of possiblePaths) {
-    if (fs.existsSync(browserPath)) {
-      return browserPath;
-    }
-  }
-  return null;
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
 }
 
 /**
- * Get Chrome user data directory
+ * Open URL in user's default browser
  */
-function getChromeUserDataDir(): string {
-  // Use a separate profile to avoid conflicts with running Chrome
-  const cnapseProfile = path.join(os.homedir(), '.cnapse', 'chrome-profile');
-
-  // Create if doesn't exist
-  if (!fs.existsSync(cnapseProfile)) {
-    fs.mkdirSync(cnapseProfile, { recursive: true });
-  }
-
-  return cnapseProfile;
-}
+export async function openUrl(url: string): Promise<{ success: boolean; error?: string }> {
+  const fullUrl = url.startsWith('http') ? url : `https://${url}`;
 
-/**
- * Initialize browser if not already running
- * Uses system Chrome with persistent profile (keeps your logins!)
- */
-export async function initBrowser(config: Partial<BrowserConfig> = {}): Promise<Page> {
-  const cfg = { ...defaultConfig, ...config };
-
-  if (!context) {
-    const browserPath = cfg.useSystemBrowser ? findSystemBrowser() : null;
-    const userDataDir = getChromeUserDataDir();
-
-    if (browserPath && cfg.useSystemBrowser) {
-      // Use persistent context with system Chrome - keeps logins!
-      context = await chromium.launchPersistentContext(userDataDir, {
-        headless: cfg.headless,
-        slowMo: cfg.slowMo,
-        viewport: cfg.viewport,
-        executablePath: browserPath,
-        channel: undefined, // Don't use channel when specifying executablePath
-        args: [
-          '--disable-blink-features=AutomationControlled', // Less bot detection
-          '--no-first-run',
-          '--no-default-browser-check',
-        ]
-      });
+  try {
+    if (process.platform === 'win32') {
+      await runCommand(`start "" "${fullUrl}"`, 5000);
+    } else if (process.platform === 'darwin') {
+      await runCommand(`open "${fullUrl}"`, 5000);
     } else {
-      // Fallback to bundled Chromium with persistent context
-      context = await chromium.launchPersistentContext(userDataDir, {
-        headless: cfg.headless,
-        slowMo: cfg.slowMo,
-        viewport: cfg.viewport,
-        args: [
-          '--disable-blink-features=AutomationControlled',
-        ]
-      });
+      await runCommand(`xdg-open "${fullUrl}"`, 5000);
     }
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to open URL'
+    };
   }
-
-  // Get existing page or create new one
-  const pages = context.pages();
-  if (pages.length > 0) {
-    activePage = pages[0];
-  } else {
-    activePage = await context.newPage();
-  }
-
-  return activePage;
 }
 
 /**
- * Get current page or create one
+ * Open browser and navigate to URL
+ * Same as openUrl but with explicit naming
  */
-export async function getPage(): Promise<Page> {
-  if (!activePage) {
-    return initBrowser();
-  }
-  return activePage;
+export async function navigateTo(url: string): Promise<void> {
+  await openUrl(url);
 }
 
 /**
- * Close browser
+ * Open browser with Google search
  */
-export async function closeBrowser(): Promise<void> {
-  if (context) {
-    await context.close();
-    context = null;
-    activePage = null;
-  }
-  if (browser) {
-    await browser.close();
-    browser = null;
-  }
+export async function searchGoogle(query: string): Promise<{ success: boolean; error?: string }> {
+  const searchUrl = `https://www.google.com/search?q=${encodeURIComponent(query)}`;
+  return openUrl(searchUrl);
 }
 
 /**
- * Navigate to URL
+ * Perform web search and describe results using vision
+ * Opens search in browser, waits for results, takes screenshot and describes
  */
-export async function navigateTo(url: string): Promise<void> {
-  const page = await getPage();
-  await page.goto(url, { waitUntil: 'domcontentloaded' });
+export async function webSearch(query: string, engine: 'google' | 'bing' | 'duckduckgo' = 'google'): Promise<string> {
+  const urls = {
+    google: `https://www.google.com/search?q=${encodeURIComponent(query)}`,
+    bing: `https://www.bing.com/search?q=${encodeURIComponent(query)}`,
+    duckduckgo: `https://duckduckgo.com/?q=${encodeURIComponent(query)}`
+  };
+
+  // Open search in browser
+  await openUrl(urls[engine]);
+
+  // Wait for page to load
+  await sleep(3000);
+
+  // Take screenshot and describe what we see
+  const vision = await describeScreen();
+
+  return `🔍 Search results for "${query}":\n\n${vision.description}`;
 }
 
 /**
- * Take screenshot and return as base64
+ * Open AI chat website and type a question
+ * Uses mouse/keyboard control to interact
  */
-export async function takeScreenshot(): Promise<string> {
-  const page = await getPage();
-  const buffer = await page.screenshot({ type: 'png' });
-  return buffer.toString('base64');
+export async function askAI(
+  site: 'perplexity' | 'chatgpt' | 'claude' | 'copilot' | 'google',
+  question: string
+): Promise<{ response: string; screenshot?: string }> {
+  const urls: Record<string, string> = {
+    perplexity: 'https://www.perplexity.ai',
+    chatgpt: 'https://chat.openai.com',
+    claude: 'https://claude.ai',
+    copilot: 'https://copilot.microsoft.com',
+    google: 'https://www.google.com'
+  };
+
+  // Open the site
+  await openUrl(urls[site]);
+
+  // Wait for page to load
+  await sleep(4000);
+
+  // Type the question using keyboard
+  await computer.typeText(question);
+  await sleep(500);
+
+  // Press Enter to submit
+  await computer.pressKey('Return');
+
+  // Wait for response to generate
+  await sleep(site === 'google' ? 3000 : 10000);
+
+  // Capture screenshot and describe what we see
+  const vision = await describeScreen();
+
+  return {
+    response: vision.description,
+    screenshot: vision.screenshot
+  };
 }
 
 /**
- * Take screenshot of specific element
+ * Open Gmail compose
  */
-export async function screenshotElement(selector: string): Promise<string | null> {
-  const page = await getPage();
-  try {
-    const element = await page.waitForSelector(selector, { timeout: 5000 });
-    if (element) {
-      const buffer = await element.screenshot({ type: 'png' });
-      return buffer.toString('base64');
-    }
-  } catch {
-    return null;
-  }
-  return null;
+export async function openGmailCompose(to?: string, subject?: string, body?: string): Promise<boolean> {
+  let url = 'https://mail.google.com/mail/u/0/?fs=1&tf=cm';
+
+  if (to) url += `&to=${encodeURIComponent(to)}`;
+  if (subject) url += `&su=${encodeURIComponent(subject)}`;
+  if (body) url += `&body=${encodeURIComponent(body)}`;
+
+  const result = await openUrl(url);
+  return result.success;
 }
 
 /**
- * Wait for element and click
+ * Send email via Gmail compose URL
+ * Opens compose with pre-filled fields, user completes manually or we automate with keyboard
  */
-export async function clickElement(selector: string, timeout = 10000): Promise<boolean> {
-  const page = await getPage();
+export async function sendGmail(email: { to: string; subject: string; body: string }): Promise<boolean> {
   try {
-    await page.click(selector, { timeout });
+    // Open Gmail compose with pre-filled fields
+    await openGmailCompose(email.to, email.subject, email.body);
+
+    // Wait for compose to open
+    await sleep(5000);
+
+    // User can review and send manually, or:
+    // Press Ctrl+Enter to send
+    await computer.keyCombo(['control', 'Return']);
+
+    await sleep(2000);
     return true;
   } catch {
     return false;
@@ -195,26 +159,33 @@ export async function clickElement(selector: string, timeout = 10000): Promise<b
 }
 
 /**
- * Type text into element
+ * Open Outlook compose
  */
-export async function typeInElement(selector: string, text: string, timeout = 10000): Promise<boolean> {
-  const page = await getPage();
-  try {
-    await page.fill(selector, text, { timeout });
-    return true;
-  } catch {
-    return false;
-  }
+export async function openOutlookCompose(to?: string, subject?: string, body?: string): Promise<boolean> {
+  let url = 'https://outlook.office.com/mail/deeplink/compose?';
+
+  if (to) url += `to=${encodeURIComponent(to)}&`;
+  if (subject) url += `subject=${encodeURIComponent(subject)}&`;
+  if (body) url += `body=${encodeURIComponent(body)}&`;
+
+  const result = await openUrl(url);
+  return result.success;
 }
 
 /**
- * Type text character by character (for sites that need keypresses)
+ * Send email via Outlook
  */
-export async function typeSlowly(selector: string, text: string, delay = 50): Promise<boolean> {
-  const page = await getPage();
+export async function sendOutlook(email: { to: string; subject: string; body: string }): Promise<boolean> {
   try {
-    await page.click(selector);
-    await page.type(selector, text, { delay });
+    await openOutlookCompose(email.to, email.subject, email.body);
+
+    // Wait for compose to open
+    await sleep(5000);
+
+    // Press Ctrl+Enter to send
+    await computer.keyCombo(['control', 'Return']);
+
+    await sleep(2000);
     return true;
   } catch {
     return false;
@@ -222,517 +193,298 @@ export async function typeSlowly(selector: string, text: string, delay = 50): Pr
 }
 
 /**
- * Press keyboard key
+ * Open new Google Sheet
  */
-export async function pressKey(key: string): Promise<void> {
-  const page = await getPage();
-  await page.keyboard.press(key);
+export async function openGoogleSheet(): Promise<boolean> {
+  const result = await openUrl('https://docs.google.com/spreadsheets/create');
+  return result.success;
 }
 
 /**
- * Scroll page
+ * Open new Google Doc
  */
-export async function scroll(direction: 'up' | 'down', amount = 500): Promise<void> {
-  const page = await getPage();
-  await page.mouse.wheel(0, direction === 'down' ? amount : -amount);
+export async function openGoogleDoc(): Promise<boolean> {
+  const result = await openUrl('https://docs.google.com/document/create');
+  return result.success;
 }
 
 /**
- * Wait for text to appear on page
+ * Type in current browser window
+ * Assumes browser is focused
  */
-export async function waitForText(text: string, timeout = 30000): Promise<boolean> {
-  const page = await getPage();
-  try {
-    await page.waitForFunction(
-      (searchText) => document.body.innerText.includes(searchText),
-      text,
-      { timeout }
-    );
-    return true;
-  } catch {
-    return false;
-  }
+export async function typeInBrowser(text: string): Promise<void> {
+  await computer.typeText(text);
 }
 
 /**
- * Get text content of element
+ * Press key in browser
  */
-export async function getTextContent(selector: string): Promise<string | null> {
-  const page = await getPage();
-  try {
-    return await page.textContent(selector);
-  } catch {
-    return null;
-  }
+export async function pressKey(key: string): Promise<void> {
+  await computer.pressKey(key);
 }
 
 /**
- * Get all text from page
+ * Click at current mouse position
  */
-export async function getPageText(): Promise<string> {
-  const page = await getPage();
-  return await page.evaluate(() => document.body.innerText);
+export async function click(button: 'left' | 'right' | 'middle' = 'left'): Promise<void> {
+  await computer.clickMouse(button);
 }
 
 /**
- * Wait for navigation
+ * Scroll in browser
  */
-export async function waitForNavigation(timeout = 30000): Promise<void> {
-  const page = await getPage();
-  await page.waitForLoadState('domcontentloaded', { timeout });
+export async function scroll(direction: 'up' | 'down', amount = 3): Promise<void> {
+  // Use Page Up/Page Down for scrolling
+  const key = direction === 'down' ? 'pagedown' : 'pageup';
+  for (let i = 0; i < amount; i++) {
+    await computer.pressKey(key);
+    await sleep(200);
+  }
 }
 
 /**
- * Check if element exists
+ * Take screenshot of current screen (not just browser)
  */
-export async function elementExists(selector: string): Promise<boolean> {
-  const page = await getPage();
-  try {
-    const element = await page.$(selector);
-    return element !== null;
-  } catch {
-    return false;
-  }
+export async function takeScreenshot(): Promise<string> {
+  return await captureScreenshot();
 }
 
-// ========================================
-// AI Chat Site Helpers
-// ========================================
-
-interface AIChatConfig {
-  url: string;
-  inputSelector: string;
-  submitSelector?: string;
-  submitKey?: string;
-  responseSelector: string;
-  waitForResponse: number;
-}
-
-const aiChatConfigs: Record<string, AIChatConfig> = {
-  perplexity: {
-    url: 'https://www.perplexity.ai',
-    inputSelector: 'textarea[placeholder*="Ask"]',
-    submitKey: 'Enter',
-    responseSelector: '.prose, [class*="answer"], [class*="response"]',
-    waitForResponse: 15000
-  },
-  chatgpt: {
-    url: 'https://chat.openai.com',
-    inputSelector: 'textarea[id="prompt-textarea"], textarea[data-id="root"]',
-    submitSelector: 'button[data-testid="send-button"]',
-    responseSelector: '[data-message-author-role="assistant"]',
-    waitForResponse: 20000
-  },
-  claude: {
-    url: 'https://claude.ai',
-    inputSelector: '[contenteditable="true"], textarea',
-    submitKey: 'Enter',
-    responseSelector: '[data-testid="message-content"]',
-    waitForResponse: 20000
-  },
-  copilot: {
-    url: 'https://copilot.microsoft.com',
-    inputSelector: 'textarea, [contenteditable="true"]',
-    submitKey: 'Enter',
-    responseSelector: '[class*="response"], [class*="message"]',
-    waitForResponse: 15000
-  },
-  google: {
-    url: 'https://www.google.com',
-    inputSelector: 'textarea[name="q"], input[name="q"]',
-    submitKey: 'Enter',
-    responseSelector: '#search',
-    waitForResponse: 5000
-  }
-};
-
 /**
- * Ask AI chat and get response
+ * Get description of current screen
  */
-export async function askAI(
-  site: keyof typeof aiChatConfigs,
-  question: string,
-  includeScreenshot = false
-): Promise<{ response: string; screenshot?: string }> {
-  const config = aiChatConfigs[site];
-  if (!config) {
-    throw new Error(`Unknown AI site: ${site}`);
-  }
-
-  const page = await getPage();
-
-  // Navigate to site
-  await page.goto(config.url, { waitUntil: 'domcontentloaded' });
-  await page.waitForTimeout(2000); // Let page fully load
-
-  // Find and fill input
-  try {
-    await page.waitForSelector(config.inputSelector, { timeout: 10000 });
-    await page.fill(config.inputSelector, question);
-  } catch {
-    // Try clicking first then typing
-    await page.click(config.inputSelector);
-    await page.type(config.inputSelector, question, { delay: 30 });
-  }
+export async function getPageText(): Promise<string> {
+  const vision = await describeScreen();
+  return vision.description;
+}
 
-  // Submit
-  if (config.submitSelector) {
-    await page.click(config.submitSelector);
-  } else if (config.submitKey) {
-    await page.keyboard.press(config.submitKey);
-  }
+/**
+ * Research a topic - opens multiple searches and gathers info
+ */
+export async function research(topic: string, maxSources = 3): Promise<{
+  query: string;
+  sources: { title: string; url: string; content: string }[];
+  summary: string;
+}> {
+  // Open Google search
+  await searchGoogle(topic);
+  await sleep(3000);
 
-  // Wait for response
-  await page.waitForTimeout(config.waitForResponse);
+  // Get vision description of search results
+  const searchResults = await describeScreen();
 
-  // Try to get response text
-  let response = '';
-  try {
-    const elements = await page.$$(config.responseSelector);
-    if (elements.length > 0) {
-      const lastElement = elements[elements.length - 1];
-      response = await lastElement.textContent() || '';
-    }
-  } catch {
-    // Fallback: get all page text
-    response = await getPageText();
-  }
+  // For now, we return the vision-based description
+  // In a real scenario, we'd click through results and gather more
+  return {
+    query: topic,
+    sources: [{
+      title: `Google search: ${topic}`,
+      url: `https://www.google.com/search?q=${encodeURIComponent(topic)}`,
+      content: searchResults.description
+    }],
+    summary: searchResults.description
+  };
+}
 
-  // Optional screenshot
-  let screenshot: string | undefined;
-  if (includeScreenshot) {
-    screenshot = await takeScreenshot();
-  }
+/**
+ * Close current browser tab (Ctrl+W)
+ */
+export async function closeTab(): Promise<void> {
+  await computer.keyCombo(['control', 'w']);
+}
 
-  return { response: response.trim(), screenshot };
+/**
+ * New browser tab (Ctrl+T)
+ */
+export async function newTab(): Promise<void> {
+  await computer.keyCombo(['control', 't']);
 }
 
 /**
- * Scroll and capture full response (for long answers)
+ * Switch browser tab (Ctrl+Tab)
  */
-export async function getFullAIResponse(
-  site: keyof typeof aiChatConfigs,
-  maxScrolls = 5
-): Promise<string[]> {
-  const config = aiChatConfigs[site];
-  const page = await getPage();
-  const responseParts: string[] = [];
+export async function nextTab(): Promise<void> {
+  await computer.keyCombo(['control', 'Tab']);
+}
 
-  for (let i = 0; i < maxScrolls; i++) {
-    try {
-      const elements = await page.$$(config.responseSelector);
-      if (elements.length > 0) {
-        const lastElement = elements[elements.length - 1];
-        const text = await lastElement.textContent();
-        if (text) {
-          responseParts.push(text.trim());
-        }
-      }
-
-      // Scroll down
-      await page.mouse.wheel(0, 500);
-      await page.waitForTimeout(1000);
-
-      // Check if we've reached the bottom
-      const atBottom = await page.evaluate(() => {
-        return window.innerHeight + window.scrollY >= document.body.scrollHeight - 100;
-      });
-      if (atBottom) break;
-    } catch {
-      break;
-    }
-  }
+/**
+ * Go back in browser (Alt+Left)
+ */
+export async function goBack(): Promise<void> {
+  await computer.keyCombo(['alt', 'Left']);
+}
 
-  return responseParts;
+/**
+ * Go forward in browser (Alt+Right)
+ */
+export async function goForward(): Promise<void> {
+  await computer.keyCombo(['alt', 'Right']);
 }
 
-// ========================================
-// Email Helpers
-// ========================================
+/**
+ * Refresh page (F5)
+ */
+export async function refresh(): Promise<void> {
+  await computer.pressKey('F5');
+}
 
-interface EmailData {
-  to: string;
-  subject: string;
-  body: string;
+/**
+ * Focus address bar (Ctrl+L)
+ */
+export async function focusAddressBar(): Promise<void> {
+  await computer.keyCombo(['control', 'l']);
 }
 
 /**
- * Send email via Gmail web interface
+ * Navigate to URL by typing in address bar
  */
-export async function sendGmail(email: EmailData): Promise<boolean> {
-  const page = await getPage();
+export async function typeUrl(url: string): Promise<void> {
+  await focusAddressBar();
+  await sleep(300);
+  await computer.typeText(url);
+  await sleep(200);
+  await computer.pressKey('Return');
+}
 
-  try {
-    // Go to Gmail compose
-    await page.goto('https://mail.google.com/mail/u/0/#inbox?compose=new');
-    await page.waitForTimeout(3000);
+// Legacy function stubs for compatibility (do nothing or minimal behavior)
+export async function initBrowser(): Promise<null> {
+  // No initialization needed - we use system browser
+  return null;
+}
 
-    // Wait for compose dialog
-    await page.waitForSelector('input[aria-label*="To"]', { timeout: 10000 });
+export async function getPage(): Promise<null> {
+  return null;
+}
 
-    // Fill To field
-    await page.fill('input[aria-label*="To"]', email.to);
-    await page.keyboard.press('Tab');
+export async function closeBrowser(): Promise<void> {
+  // Close browser window with Alt+F4
+  await computer.keyCombo(['alt', 'F4']);
+}
 
-    // Fill Subject
-    await page.fill('input[name="subjectbox"]', email.subject);
-    await page.keyboard.press('Tab');
+export async function elementExists(selector: string): Promise<boolean> {
+  // Can't check DOM without Playwright - always return true to not block
+  return true;
+}
 
-    // Fill Body
-    await page.fill('[aria-label*="Message Body"], [role="textbox"]', email.body);
+export async function clickElement(selector: string): Promise<boolean> {
+  // Without Playwright, we can't click by selector
+  // Just click at current position
+  await click();
+  return true;
+}
 
-    // Click Send (Ctrl+Enter is faster)
-    await page.keyboard.press('Control+Enter');
+export async function typeInElement(selector: string, text: string): Promise<boolean> {
+  // Just type the text
+  await typeInBrowser(text);
+  return true;
+}
 
-    await page.waitForTimeout(2000);
-    return true;
-  } catch {
-    return false;
+export async function typeSlowly(selector: string, text: string): Promise<boolean> {
+  // Type character by character
+  for (const char of text) {
+    await computer.typeText(char);
+    await sleep(50);
   }
+  return true;
 }
 
-/**
- * Send email via Outlook web interface
- */
-export async function sendOutlook(email: EmailData): Promise<boolean> {
-  const page = await getPage();
-
-  try {
-    // Go to Outlook compose
-    await page.goto('https://outlook.office.com/mail/0/inbox');
-    await page.waitForTimeout(3000);
-
-    // Click New Message
-    await page.click('button[aria-label*="New mail"], button[title*="New mail"]');
-    await page.waitForTimeout(2000);
-
-    // Fill To
-    await page.fill('input[aria-label*="To"]', email.to);
-    await page.keyboard.press('Tab');
+export async function waitForText(text: string): Promise<boolean> {
+  // Can't check DOM - just wait a bit
+  await sleep(3000);
+  return true;
+}
 
-    // Fill Subject
-    await page.fill('input[aria-label*="Subject"], input[placeholder*="Subject"]', email.subject);
-    await page.keyboard.press('Tab');
+export async function getTextContent(selector: string): Promise<string | null> {
+  // Use vision to describe what's on screen
+  const vision = await describeScreen();
+  return vision.description;
+}
 
-    // Fill Body
-    await page.fill('[aria-label*="Message body"], [role="textbox"]', email.body);
+export async function waitForNavigation(): Promise<void> {
+  await sleep(3000);
+}
 
-    // Click Send
-    await page.click('button[aria-label*="Send"], button[title*="Send"]');
+export async function getFullAIResponse(site: string, maxScrolls = 5): Promise<string[]> {
+  // Scroll down and capture what we see
+  const responses: string[] = [];
 
-    await page.waitForTimeout(2000);
-    return true;
-  } catch {
-    return false;
+  for (let i = 0; i < maxScrolls; i++) {
+    const vision = await describeScreen();
+    responses.push(vision.description);
+    await scroll('down', 1);
+    await sleep(1000);
   }
-}
-
-// ========================================
-// Google Apps Helpers
-// ========================================
 
-/**
- * Create new Google Sheet and type in cells
- */
-export async function googleSheetsType(cellData: { cell: string; value: string }[]): Promise<boolean> {
-  const page = await getPage();
+  return responses;
+}
 
+export async function googleSheetsType(cells: { cell: string; value: string }[]): Promise<boolean> {
   try {
-    // Go to Google Sheets
-    await page.goto('https://docs.google.com/spreadsheets/create');
-    await page.waitForTimeout(5000);
-
-    for (const { cell, value } of cellData) {
-      // Click on name box and type cell reference
-      await page.click('input#t-name-box');
-      await page.fill('input#t-name-box', cell);
-      await page.keyboard.press('Enter');
-      await page.waitForTimeout(500);
-
-      // Type value
-      await page.keyboard.type(value);
-      await page.keyboard.press('Enter');
-      await page.waitForTimeout(300);
+    for (const { cell, value } of cells) {
+      // Press Ctrl+G to go to cell (or use name box with Ctrl+G)
+      await computer.keyCombo(['control', 'g']);
+      await sleep(500);
+      await computer.typeText(cell);
+      await computer.pressKey('Return');
+      await sleep(300);
+      await computer.typeText(value);
+      await computer.pressKey('Return');
+      await sleep(200);
     }
-
     return true;
   } catch {
     return false;
   }
 }
 
-/**
- * Create new Google Doc and type
- */
 export async function googleDocsType(text: string): Promise<boolean> {
-  const page = await getPage();
-
   try {
-    // Go to Google Docs
-    await page.goto('https://docs.google.com/document/create');
-    await page.waitForTimeout(5000);
-
-    // Click on document body
-    await page.click('.kix-appview-editor');
-    await page.waitForTimeout(500);
-
-    // Type text
-    await page.keyboard.type(text, { delay: 20 });
-
+    await sleep(1000);
+    await computer.typeText(text);
     return true;
   } catch {
     return false;
   }
 }
 
-// ========================================
-// Web Search
-// ========================================
-
-/**
- * Perform web search and get results
- */
-export async function webSearch(query: string, engine: 'google' | 'bing' | 'duckduckgo' = 'google'): Promise<string[]> {
-  const page = await getPage();
-  const results: string[] = [];
-
-  const urls = {
-    google: 'https://www.google.com',
-    bing: 'https://www.bing.com',
-    duckduckgo: 'https://duckduckgo.com'
-  };
-
-  const selectors = {
-    google: { input: 'textarea[name="q"]', results: '#search .g h3' },
-    bing: { input: 'input[name="q"]', results: '#b_results h2 a' },
-    duckduckgo: { input: 'input[name="q"]', results: '[data-result] h2' }
-  };
-
-  try {
-    await page.goto(urls[engine]);
-    await page.waitForTimeout(2000);
-
-    // Search
-    await page.fill(selectors[engine].input, query);
-    await page.keyboard.press('Enter');
-    await page.waitForTimeout(3000);
-
-    // Get result titles
-    const elements = await page.$$(selectors[engine].results);
-    for (const el of elements.slice(0, 10)) {
-      const text = await el.textContent();
-      if (text) results.push(text);
-    }
-  } catch {
-    // Return empty on error
-  }
-
-  return results;
-}
-
-/**
- * Click on search result by index
- */
-export async function clickSearchResult(index: number): Promise<boolean> {
-  const page = await getPage();
-
-  try {
-    const results = await page.$$('#search .g h3, #b_results h2 a, [data-result] h2 a');
-    if (results[index]) {
-      await results[index].click();
-      await page.waitForTimeout(2000);
-      return true;
-    }
-  } catch {}
-
-  return false;
-}
-
-// ========================================
-// Research Helper (multi-step)
-// ========================================
-
-export interface ResearchResult {
-  query: string;
-  sources: { title: string; url: string; content: string }[];
-  summary: string;
-}
-
-/**
- * Research a topic: search, visit results, gather info
- */
-export async function research(topic: string, maxSources = 3): Promise<ResearchResult> {
-  const page = await getPage();
-  const sources: { title: string; url: string; content: string }[] = [];
-
-  // Search
-  await webSearch(topic);
-  await page.waitForTimeout(2000);
-
-  // Visit top results
-  for (let i = 0; i < maxSources; i++) {
-    try {
-      const results = await page.$$('#search .g');
-      if (results[i]) {
-        // Get title and URL
-        const titleEl = await results[i].$('h3');
-        const linkEl = await results[i].$('a');
-
-        const title = await titleEl?.textContent() || 'Unknown';
-        const url = await linkEl?.getAttribute('href') || '';
-
-        // Click and get content
-        await titleEl?.click();
-        await page.waitForTimeout(3000);
-
-        // Get main content
-        const content = await page.evaluate(() => {
-          const article = document.querySelector('article, main, .content, #content');
-          return article?.textContent?.slice(0, 2000) || document.body.innerText.slice(0, 2000);
-        });
-
-        sources.push({ title, url, content: content.trim() });
-
-        // Go back
-        await page.goBack();
-        await page.waitForTimeout(1500);
-      }
-    } catch {
-      continue;
-    }
-  }
-
-  return {
-    query: topic,
-    sources,
-    summary: '' // To be filled by AI
-  };
-}
-
 export default {
+  openUrl,
+  navigateTo,
+  searchGoogle,
+  webSearch,
+  askAI,
+  openGmailCompose,
+  sendGmail,
+  openOutlookCompose,
+  sendOutlook,
+  openGoogleSheet,
+  openGoogleDoc,
+  typeInBrowser,
+  pressKey,
+  click,
+  scroll,
+  takeScreenshot,
+  getPageText,
+  research,
+  closeTab,
+  newTab,
+  nextTab,
+  goBack,
+  goForward,
+  refresh,
+  focusAddressBar,
+  typeUrl,
+  // Legacy compatibility
   initBrowser,
   getPage,
   closeBrowser,
-  navigateTo,
-  takeScreenshot,
-  screenshotElement,
+  elementExists,
   clickElement,
   typeInElement,
   typeSlowly,
-  pressKey,
-  scroll,
   waitForText,
   getTextContent,
-  getPageText,
   waitForNavigation,
-  elementExists,
-  askAI,
   getFullAIResponse,
-  sendGmail,
-  sendOutlook,
   googleSheetsType,
-  googleDocsType,
-  webSearch,
-  clickSearchResult,
-  research
+  googleDocsType
 };