@projectservan8n/cnapse 0.8.2 → 0.9.0

package/dist/index.js

@@ -586,10 +586,10 @@ async function captureScreenFallback() {
   const { exec: exec5 } = await import("child_process");
   const { promisify: promisify5 } = await import("util");
   const { tmpdir } = await import("os");
-  const { join: join4 } = await import("path");
+  const { join: join3 } = await import("path");
   const { readFile: readFile2, unlink } = await import("fs/promises");
   const execAsync5 = promisify5(exec5);
-  const tempFile = join4(tmpdir(), `cnapse-screen-${Date.now()}.png`);
+  const tempFile = join3(tmpdir(), `cnapse-screen-${Date.now()}.png`);
   try {
     const platform = process.platform;
     if (platform === "win32") {
@@ -902,29 +902,29 @@ import { promisify as promisify4 } from "util";
 // src/tools/filesystem.ts
 import { promises as fs } from "fs";
 import { join, dirname } from "path";
-async function readFile(path3) {
+async function readFile(path2) {
   try {
-    const content = await fs.readFile(path3, "utf-8");
+    const content = await fs.readFile(path2, "utf-8");
     return ok(content);
   } catch (error) {
     return err(`Failed to read file: ${error.message}`);
   }
 }
-async function writeFile(path3, content) {
+async function writeFile(path2, content) {
   try {
-    const dir = dirname(path3);
+    const dir = dirname(path2);
     await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(path3, content, "utf-8");
-    return ok(`Written ${content.length} bytes to ${path3}`);
+    await fs.writeFile(path2, content, "utf-8");
+    return ok(`Written ${content.length} bytes to ${path2}`);
   } catch (error) {
     return err(`Failed to write file: ${error.message}`);
   }
 }
-async function listDir(path3, recursive = false) {
+async function listDir(path2, recursive = false) {
   try {
-    const stat = await fs.stat(path3);
+    const stat = await fs.stat(path2);
     if (!stat.isDirectory()) {
-      return err(`Not a directory: ${path3}`);
+      return err(`Not a directory: ${path2}`);
     }
     const entries = [];
     async function walkDir(dir, prefix) {
@@ -941,7 +941,7 @@ async function listDir(path3, recursive = false) {
         }
       }
     }
-    await walkDir(path3, "");
+    await walkDir(path2, "");
     entries.sort();
     return ok(entries.join("\n"));
   } catch (error) {
@@ -1459,288 +1459,146 @@ ${stderr}`
 }
 
 // src/services/browser.ts
-import { chromium } from "playwright";
-import * as path from "path";
-import * as os2 from "os";
-import * as fs2 from "fs";
-var context = null;
-var activePage = null;
-var defaultConfig = {
-  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
-};
-function findSystemBrowser() {
-  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 (fs2.existsSync(browserPath)) {
-      return browserPath;
-    }
-  }
-  return null;
-}
-function getChromeUserDataDir() {
-  const cnapseProfile = path.join(os2.homedir(), ".cnapse", "chrome-profile");
-  if (!fs2.existsSync(cnapseProfile)) {
-    fs2.mkdirSync(cnapseProfile, { recursive: true });
-  }
-  return cnapseProfile;
-}
-async function initBrowser(config = {}) {
-  const cfg = { ...defaultConfig, ...config };
-  if (!context) {
-    const browserPath = cfg.useSystemBrowser ? findSystemBrowser() : null;
-    const userDataDir = getChromeUserDataDir();
-    if (browserPath && cfg.useSystemBrowser) {
-      context = await chromium.launchPersistentContext(userDataDir, {
-        headless: cfg.headless,
-        slowMo: cfg.slowMo,
-        viewport: cfg.viewport,
-        executablePath: browserPath,
-        channel: void 0,
-        // Don't use channel when specifying executablePath
-        args: [
-          "--disable-blink-features=AutomationControlled",
-          // Less bot detection
-          "--no-first-run",
-          "--no-default-browser-check"
-        ]
-      });
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function openUrl(url) {
+  const fullUrl = url.startsWith("http") ? url : `https://${url}`;
+  try {
+    if (process.platform === "win32") {
+      await runCommand(`start "" "${fullUrl}"`, 5e3);
+    } else if (process.platform === "darwin") {
+      await runCommand(`open "${fullUrl}"`, 5e3);
     } else {
-      context = await chromium.launchPersistentContext(userDataDir, {
-        headless: cfg.headless,
-        slowMo: cfg.slowMo,
-        viewport: cfg.viewport,
-        args: [
-          "--disable-blink-features=AutomationControlled"
-        ]
-      });
+      await runCommand(`xdg-open "${fullUrl}"`, 5e3);
     }
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to open URL"
+    };
   }
-  const pages = context.pages();
-  if (pages.length > 0) {
-    activePage = pages[0];
-  } else {
-    activePage = await context.newPage();
-  }
-  return activePage;
 }
-async function getPage() {
-  if (!activePage) {
-    return initBrowser();
-  }
-  return activePage;
+async function searchGoogle(query) {
+  const searchUrl = `https://www.google.com/search?q=${encodeURIComponent(query)}`;
+  return openUrl(searchUrl);
 }
-async function navigateTo(url) {
-  const page = await getPage();
-  await page.goto(url, { waitUntil: "domcontentloaded" });
+async function webSearch(query, engine = "google") {
+  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)}`
+  };
+  await openUrl(urls[engine]);
+  await sleep(3e3);
+  const vision = await describeScreen();
+  return `\u{1F50D} Search results for "${query}":
+
+${vision.description}`;
 }
-async function takeScreenshot() {
-  const page = await getPage();
-  const buffer = await page.screenshot({ type: "png" });
-  return buffer.toString("base64");
+async function askAI(site, question) {
+  const urls = {
+    perplexity: "https://www.perplexity.ai",
+    chatgpt: "https://chat.openai.com",
+    claude: "https://claude.ai",
+    copilot: "https://copilot.microsoft.com",
+    google: "https://www.google.com"
+  };
+  await openUrl(urls[site]);
+  await sleep(4e3);
+  await typeText(question);
+  await sleep(500);
+  await pressKey("Return");
+  await sleep(site === "google" ? 3e3 : 1e4);
+  const vision = await describeScreen();
+  return {
+    response: vision.description,
+    screenshot: vision.screenshot
+  };
 }
-async function clickElement(selector, timeout = 1e4) {
-  const page = await getPage();
-  try {
-    await page.click(selector, { timeout });
-    return true;
-  } catch {
-    return false;
-  }
+async function openGmailCompose(to, subject, body) {
+  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;
 }
-async function typeInElement(selector, text, timeout = 1e4) {
-  const page = await getPage();
+async function sendGmail(email) {
   try {
-    await page.fill(selector, text, { timeout });
+    await openGmailCompose(email.to, email.subject, email.body);
+    await sleep(5e3);
+    await keyCombo(["control", "Return"]);
+    await sleep(2e3);
     return true;
   } catch {
     return false;
   }
 }
-async function pressKey2(key) {
-  const page = await getPage();
-  await page.keyboard.press(key);
+async function openOutlookCompose(to, subject, body) {
+  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;
 }
-async function scroll(direction, amount = 500) {
-  const page = await getPage();
-  await page.mouse.wheel(0, direction === "down" ? amount : -amount);
-}
-async function getPageText() {
-  const page = await getPage();
-  return await page.evaluate(() => document.body.innerText);
-}
-async function elementExists(selector) {
-  const page = await getPage();
+async function sendOutlook(email) {
   try {
-    const element = await page.$(selector);
-    return element !== null;
+    await openOutlookCompose(email.to, email.subject, email.body);
+    await sleep(5e3);
+    await keyCombo(["control", "Return"]);
+    await sleep(2e3);
+    return true;
   } catch {
     return false;
   }
 }
-var aiChatConfigs = {
-  perplexity: {
-    url: "https://www.perplexity.ai",
-    inputSelector: 'textarea[placeholder*="Ask"]',
-    submitKey: "Enter",
-    responseSelector: '.prose, [class*="answer"], [class*="response"]',
-    waitForResponse: 15e3
-  },
-  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: 2e4
-  },
-  claude: {
-    url: "https://claude.ai",
-    inputSelector: '[contenteditable="true"], textarea',
-    submitKey: "Enter",
-    responseSelector: '[data-testid="message-content"]',
-    waitForResponse: 2e4
-  },
-  copilot: {
-    url: "https://copilot.microsoft.com",
-    inputSelector: 'textarea, [contenteditable="true"]',
-    submitKey: "Enter",
-    responseSelector: '[class*="response"], [class*="message"]',
-    waitForResponse: 15e3
-  },
-  google: {
-    url: "https://www.google.com",
-    inputSelector: 'textarea[name="q"], input[name="q"]',
-    submitKey: "Enter",
-    responseSelector: "#search",
-    waitForResponse: 5e3
-  }
-};
-async function askAI(site, question, includeScreenshot = false) {
-  const config = aiChatConfigs[site];
-  if (!config) {
-    throw new Error(`Unknown AI site: ${site}`);
-  }
-  const page = await getPage();
-  await page.goto(config.url, { waitUntil: "domcontentloaded" });
-  await page.waitForTimeout(2e3);
-  try {
-    await page.waitForSelector(config.inputSelector, { timeout: 1e4 });
-    await page.fill(config.inputSelector, question);
-  } catch {
-    await page.click(config.inputSelector);
-    await page.type(config.inputSelector, question, { delay: 30 });
-  }
-  if (config.submitSelector) {
-    await page.click(config.submitSelector);
-  } else if (config.submitKey) {
-    await page.keyboard.press(config.submitKey);
-  }
-  await page.waitForTimeout(config.waitForResponse);
-  let response = "";
-  try {
-    const elements = await page.$$(config.responseSelector);
-    if (elements.length > 0) {
-      const lastElement = elements[elements.length - 1];
-      response = await lastElement.textContent() || "";
-    }
-  } catch {
-    response = await getPageText();
-  }
-  let screenshot;
-  if (includeScreenshot) {
-    screenshot = await takeScreenshot();
-  }
-  return { response: response.trim(), screenshot };
+async function openGoogleSheet() {
+  const result = await openUrl("https://docs.google.com/spreadsheets/create");
+  return result.success;
 }
-async function getFullAIResponse(site, maxScrolls = 5) {
-  const config = aiChatConfigs[site];
-  const page = await getPage();
-  const responseParts = [];
-  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());
-        }
-      }
-      await page.mouse.wheel(0, 500);
-      await page.waitForTimeout(1e3);
-      const atBottom = await page.evaluate(() => {
-        return window.innerHeight + window.scrollY >= document.body.scrollHeight - 100;
-      });
-      if (atBottom) break;
-    } catch {
-      break;
-    }
-  }
-  return responseParts;
+async function openGoogleDoc() {
+  const result = await openUrl("https://docs.google.com/document/create");
+  return result.success;
 }
-async function sendGmail(email) {
-  const page = await getPage();
-  try {
-    await page.goto("https://mail.google.com/mail/u/0/#inbox?compose=new");
-    await page.waitForTimeout(3e3);
-    await page.waitForSelector('input[aria-label*="To"]', { timeout: 1e4 });
-    await page.fill('input[aria-label*="To"]', email.to);
-    await page.keyboard.press("Tab");
-    await page.fill('input[name="subjectbox"]', email.subject);
-    await page.keyboard.press("Tab");
-    await page.fill('[aria-label*="Message Body"], [role="textbox"]', email.body);
-    await page.keyboard.press("Control+Enter");
-    await page.waitForTimeout(2e3);
-    return true;
-  } catch {
-    return false;
+async function scroll(direction, amount = 3) {
+  const key = direction === "down" ? "pagedown" : "pageup";
+  for (let i = 0; i < amount; i++) {
+    await pressKey(key);
+    await sleep(200);
   }
 }
-async function sendOutlook(email) {
-  const page = await getPage();
-  try {
-    await page.goto("https://outlook.office.com/mail/0/inbox");
-    await page.waitForTimeout(3e3);
-    await page.click('button[aria-label*="New mail"], button[title*="New mail"]');
-    await page.waitForTimeout(2e3);
-    await page.fill('input[aria-label*="To"]', email.to);
-    await page.keyboard.press("Tab");
-    await page.fill('input[aria-label*="Subject"], input[placeholder*="Subject"]', email.subject);
-    await page.keyboard.press("Tab");
-    await page.fill('[aria-label*="Message body"], [role="textbox"]', email.body);
-    await page.click('button[aria-label*="Send"], button[title*="Send"]');
-    await page.waitForTimeout(2e3);
-    return true;
-  } catch {
-    return false;
-  }
+async function getPageText() {
+  const vision = await describeScreen();
+  return vision.description;
+}
+async function research(topic, maxSources = 3) {
+  await searchGoogle(topic);
+  await sleep(3e3);
+  const searchResults = await describeScreen();
+  return {
+    query: topic,
+    sources: [{
+      title: `Google search: ${topic}`,
+      url: `https://www.google.com/search?q=${encodeURIComponent(topic)}`,
+      content: searchResults.description
+    }],
+    summary: searchResults.description
+  };
 }
-async function googleSheetsType(cellData) {
-  const page = await getPage();
+async function googleSheetsType(cells) {
   try {
-    await page.goto("https://docs.google.com/spreadsheets/create");
-    await page.waitForTimeout(5e3);
-    for (const { cell, value } of cellData) {
-      await page.click("input#t-name-box");
-      await page.fill("input#t-name-box", cell);
-      await page.keyboard.press("Enter");
-      await page.waitForTimeout(500);
-      await page.keyboard.type(value);
-      await page.keyboard.press("Enter");
-      await page.waitForTimeout(300);
+    for (const { cell, value } of cells) {
+      await keyCombo(["control", "g"]);
+      await sleep(500);
+      await typeText(cell);
+      await pressKey("Return");
+      await sleep(300);
+      await typeText(value);
+      await pressKey("Return");
+      await sleep(200);
     }
     return true;
   } catch {
@@ -1748,90 +1606,24 @@ async function googleSheetsType(cellData) {
   }
 }
 async function googleDocsType(text) {
-  const page = await getPage();
   try {
-    await page.goto("https://docs.google.com/document/create");
-    await page.waitForTimeout(5e3);
-    await page.click(".kix-appview-editor");
-    await page.waitForTimeout(500);
-    await page.keyboard.type(text, { delay: 20 });
+    await sleep(1e3);
+    await typeText(text);
     return true;
   } catch {
     return false;
   }
 }
-async function webSearch(query, engine = "google") {
-  const page = await getPage();
-  const results = [];
-  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(2e3);
-    await page.fill(selectors[engine].input, query);
-    await page.keyboard.press("Enter");
-    await page.waitForTimeout(3e3);
-    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 results;
-}
-async function research(topic, maxSources = 3) {
-  const page = await getPage();
-  const sources = [];
-  await webSearch(topic);
-  await page.waitForTimeout(2e3);
-  for (let i = 0; i < maxSources; i++) {
-    try {
-      const results = await page.$$("#search .g");
-      if (results[i]) {
-        const titleEl = await results[i].$("h3");
-        const linkEl = await results[i].$("a");
-        const title = await titleEl?.textContent() || "Unknown";
-        const url = await linkEl?.getAttribute("href") || "";
-        await titleEl?.click();
-        await page.waitForTimeout(3e3);
-        const content = await page.evaluate(() => {
-          const article = document.querySelector("article, main, .content, #content");
-          return article?.textContent?.slice(0, 2e3) || document.body.innerText.slice(0, 2e3);
-        });
-        sources.push({ title, url, content: content.trim() });
-        await page.goBack();
-        await page.waitForTimeout(1500);
-      }
-    } catch {
-      continue;
-    }
-  }
-  return {
-    query: topic,
-    sources,
-    summary: ""
-    // To be filled by AI
-  };
-}
 
 // src/lib/tasks.ts
-import * as fs3 from "fs";
-import * as path2 from "path";
-import * as os3 from "os";
-var TASK_MEMORY_FILE = path2.join(os3.homedir(), ".cnapse", "task-memory.json");
+import * as fs2 from "fs";
+import * as path from "path";
+import * as os2 from "os";
+var TASK_MEMORY_FILE = path.join(os2.homedir(), ".cnapse", "task-memory.json");
 function loadTaskMemory() {
   try {
-    if (fs3.existsSync(TASK_MEMORY_FILE)) {
-      const data = fs3.readFileSync(TASK_MEMORY_FILE, "utf-8");
+    if (fs2.existsSync(TASK_MEMORY_FILE)) {
+      const data = fs2.readFileSync(TASK_MEMORY_FILE, "utf-8");
       return JSON.parse(data);
     }
   } catch {
@@ -1857,11 +1649,11 @@ function saveTaskPattern(input, steps) {
       });
     }
     memory.patterns = memory.patterns.sort((a, b) => b.successCount - a.successCount).slice(0, 100);
-    const dir = path2.dirname(TASK_MEMORY_FILE);
-    if (!fs3.existsSync(dir)) {
-      fs3.mkdirSync(dir, { recursive: true });
+    const dir = path.dirname(TASK_MEMORY_FILE);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
     }
-    fs3.writeFileSync(TASK_MEMORY_FILE, JSON.stringify(memory, null, 2));
+    fs2.writeFileSync(TASK_MEMORY_FILE, JSON.stringify(memory, null, 2));
   } catch {
   }
 }
@@ -2212,9 +2004,9 @@ async function executeStep(step) {
   switch (actionType) {
     case "open_app":
       await keyCombo(["meta", "r"]);
-      await sleep(500);
+      await sleep2(500);
       await typeText(params);
-      await sleep(300);
+      await sleep2(300);
       await pressKey("Return");
       step.result = `Opened ${params}`;
       break;
@@ -2238,7 +2030,7 @@ async function executeStep(step) {
       break;
     case "wait":
       const seconds = parseInt(params) || 1;
-      await sleep(seconds * 1e3);
+      await sleep2(seconds * 1e3);
       step.result = `Waited ${seconds}s`;
       break;
     case "focus_window":
@@ -2348,32 +2140,17 @@ ${existingResult.output}`;
       const supportedSites = ["perplexity", "chatgpt", "claude", "copilot", "google"];
       const siteLower = site.toLowerCase();
       if (supportedSites.includes(siteLower)) {
-        const result = await askAI(siteLower, question, true);
-        if (result.response.length < 500) {
-          const fullParts = await getFullAIResponse(siteLower, 5);
-          if (fullParts.length > 0) {
-            step.result = `\u{1F4DD} ${site.charAt(0).toUpperCase() + site.slice(1)} says:
-
-${fullParts.join("\n\n")}`;
-            break;
-          }
-        }
+        const result = await askAI(siteLower, question);
         step.result = `\u{1F4DD} ${site.charAt(0).toUpperCase() + site.slice(1)} says:
 
 ${result.response}`;
       } else {
-        await navigateTo(`https://${site}`);
-        await sleep(2e3);
-        const page = await getPage();
-        const inputs = ["textarea", 'input[type="text"]', 'input[type="search"]', '[contenteditable="true"]'];
-        for (const selector of inputs) {
-          if (await elementExists(selector)) {
-            await typeInElement(selector, question);
-            await pressKey2("Enter");
-            break;
-          }
-        }
-        await sleep(5e3);
+        await openUrl(`https://${site}`);
+        await sleep2(4e3);
+        await typeText(question);
+        await sleep2(300);
+        await pressKey("Return");
+        await sleep2(5e3);
         const pageText = await getPageText();
         step.result = `\u{1F4DD} Response from ${site}:
 
@@ -2386,17 +2163,8 @@ ${pageText.slice(0, 3e3)}`;
       step.result = vision.description;
       break;
     case "web_search": {
-      const searchResults = await webSearch(params, "google");
-      if (searchResults.length > 0) {
-        step.result = `\u{1F50D} Search results for "${params}":
-
-${searchResults.map((r, i) => `${i + 1}. ${r}`).join("\n")}`;
-      } else {
-        const pageText = await getPageText();
-        step.result = `\u{1F50D} Search results for "${params}":
-
-${pageText.slice(0, 2e3)}`;
-      }
+      const searchResult = await webSearch(params, "google");
+      step.result = searchResult;
       break;
     }
     case "send_email": {
@@ -2412,9 +2180,9 @@ ${pageText.slice(0, 2e3)}`;
         throw new Error(`Unsupported email provider: ${provider}. Use gmail or outlook.`);
       }
       if (success) {
-        step.result = `\u{1F4E7} Email sent via ${provider} to ${to}`;
+        step.result = `\u{1F4E7} Email composed via ${provider} to ${to} (check browser to confirm send)`;
       } else {
-        throw new Error(`Failed to send email via ${provider}. Make sure you're logged in.`);
+        throw new Error(`Failed to open email via ${provider}. Make sure you're logged in.`);
       }
       break;
     }
@@ -2423,9 +2191,9 @@ ${pageText.slice(0, 2e3)}`;
       switch (sheetCmd.toLowerCase()) {
         case "new": {
           const sheetName = sheetArgs[0] || "Untitled spreadsheet";
-          await navigateTo("https://docs.google.com/spreadsheets/create");
-          await sleep(5e3);
-          step.result = `\u{1F4CA} Created Google Sheet: ${sheetName}`;
+          await openGoogleSheet();
+          await sleep2(5e3);
+          step.result = `\u{1F4CA} Opened new Google Sheet: ${sheetName}`;
           break;
         }
         case "type": {
@@ -2436,13 +2204,9 @@ ${pageText.slice(0, 2e3)}`;
           break;
         }
         case "read": {
-          const screenshot = await takeScreenshot();
-          const analysis = await chat([{
-            role: "user",
-            content: "Describe the contents of this Google Sheet. List visible data in the cells."
-          }]);
+          const vision2 = await describeScreen();
           step.result = `\u{1F4CA} Current sheet view:
-${analysis.content}`;
+${vision2.description}`;
           break;
         }
         default:
@@ -2455,8 +2219,9 @@ ${analysis.content}`;
       switch (docCmd.toLowerCase()) {
         case "new": {
           const docName = docArgs[0] || "Untitled document";
-          const success = await googleDocsType("");
-          step.result = success ? `\u{1F4C4} Created Google Doc: ${docName}` : `\u{1F4C4} Could not create Google Doc`;
+          await openGoogleDoc();
+          await sleep2(5e3);
+          step.result = `\u{1F4C4} Opened new Google Doc: ${docName}`;
           break;
         }
         case "type": {
@@ -2473,15 +2238,11 @@ ${analysis.content}`;
     case "research": {
       const researchQuery = params;
       const researchData = await research(researchQuery, 3);
-      const sourceSummaries = researchData.sources.map(
-        (s, i) => `Source ${i + 1}: ${s.title}
-${s.content.slice(0, 500)}...`
-      ).join("\n\n");
       const synthesis = await chat([{
         role: "user",
-        content: `Based on the following research gathered about "${researchQuery}", provide a comprehensive summary:
+        content: `Based on the following search results about "${researchQuery}", provide a comprehensive summary:
 
-${sourceSummaries}
+${researchData.summary}
 
 Create a well-organized summary with:
 1. Key findings
@@ -2508,12 +2269,10 @@ Here's what I see on my screen: ${currentScreen.description}`;
       if (!supportedLLMs.includes(llmLower)) {
         throw new Error(`Unknown LLM: ${llmName}. Supported: ${supportedLLMs.join(", ")}`);
       }
-      const result = await askAI(llmLower, fullQuestion, false);
-      const fullParts = await getFullAIResponse(llmLower, 3);
-      const finalResponse = fullParts.length > 0 ? fullParts.join("\n\n") : result.response;
+      const result = await askAI(llmLower, fullQuestion);
       step.result = `\u{1F916} ${llmName} says:
 
-${finalResponse}`;
+${result.response}`;
       break;
     }
     case "learn_ui": {
@@ -2542,48 +2301,40 @@ ${uiAnalysis.content}`;
       const maxAttempts = 5;
       const actionHistory = [];
       let accomplished = false;
-      const page = await getPage();
       for (let attempt = 0; attempt < maxAttempts && !accomplished; attempt++) {
-        const screenshot = await takeScreenshot();
-        const currentState = await chat([{
-          role: "user",
-          content: `Describe what you see on this screen. What app/website is it? What elements are visible?`
-        }]);
+        const currentScreen = await describeScreen();
         const nextAction = await chat([{
           role: "user",
           content: `GOAL: ${goal}
 
-CURRENT SCREEN: ${currentState.content}
+CURRENT SCREEN: ${currentScreen.description}
 
 PREVIOUS ACTIONS TAKEN:
 ${actionHistory.length > 0 ? actionHistory.join("\n") : "None yet"}
 
 Based on what you see, what's the SINGLE next action to take?
 Options:
-- click: Click element (describe CSS selector or visible text)
-- type: Type something (specify selector and text)
-- press: Press a key (specify key)
+- click: Click (will click at current mouse position)
+- type: Type something (specify text)
+- press: Press a key (specify key like Enter, Tab, Escape)
 - scroll: Scroll up/down
-- navigate: Go to URL
+- navigate: Go to URL (opens in browser)
 - done: Goal is accomplished
 - stuck: Can't figure out what to do
 
 Respond in format:
 ACTION: <action_type>
-SELECTOR: <css selector or text to find>
-VALUE: <text to type or URL>
+VALUE: <text to type, URL to navigate, or key to press>
 REASONING: <why>`
         }]);
         const actionContent = nextAction.content;
         const actionMatch = actionContent.match(/ACTION:\s*(\w+)/i);
-        const selectorMatch = actionContent.match(/SELECTOR:\s*(.+?)(?:\n|$)/i);
         const valueMatch = actionContent.match(/VALUE:\s*(.+?)(?:\n|$)/i);
         if (!actionMatch) {
           actionHistory.push(`Attempt ${attempt + 1}: Couldn't parse action`);
           continue;
         }
         const action = actionMatch[1].toLowerCase();
-        const selector = selectorMatch?.[1]?.trim() || "";
         const value = valueMatch?.[1]?.trim() || "";
         if (action === "done") {
           accomplished = true;
@@ -2595,34 +2346,25 @@ REASONING: <why>`
           const helpRequest = `I'm trying to: ${goal}
 
 I'm stuck. What should I do next? Be specific about what to click or type.`;
-          const advice = await askAI("perplexity", helpRequest, false);
+          const advice = await askAI("perplexity", helpRequest);
           actionHistory.push(`Got advice: ${advice.response.slice(0, 200)}...`);
-          await navigateTo(page.url());
           continue;
         }
         try {
           switch (action) {
             case "click":
-              if (selector) {
-                const clicked = await clickElement(selector);
-                if (!clicked) {
-                  await page.getByText(selector).first().click({ timeout: 5e3 });
-                }
-              }
-              actionHistory.push(`Attempt ${attempt + 1}: Clicked "${selector}"`);
+              await clickMouse("left");
+              actionHistory.push(`Attempt ${attempt + 1}: Clicked`);
               break;
             case "type":
-              if (selector && value) {
-                const typed = await typeInElement(selector, value);
-                if (!typed) {
-                  await page.getByPlaceholder(selector).first().fill(value);
-                }
+              if (value) {
+                await typeText(value);
               }
-              actionHistory.push(`Attempt ${attempt + 1}: Typed "${value}" in "${selector}"`);
+              actionHistory.push(`Attempt ${attempt + 1}: Typed "${value}"`);
               break;
             case "press":
-              await pressKey2(value || selector);
-              actionHistory.push(`Attempt ${attempt + 1}: Pressed ${value || selector}`);
+              await pressKey(value || "Return");
+              actionHistory.push(`Attempt ${attempt + 1}: Pressed ${value || "Enter"}`);
               break;
             case "scroll":
               await scroll(value.toLowerCase().includes("up") ? "up" : "down");
@@ -2630,8 +2372,8 @@ I'm stuck. What should I do next? Be specific about what to click or type.`;
               break;
             case "navigate":
               const url = value.startsWith("http") ? value : `https://${value}`;
-              await navigateTo(url);
-              actionHistory.push(`Attempt ${attempt + 1}: Navigated to ${url}`);
+              await openUrl(url);
+              actionHistory.push(`Attempt ${attempt + 1}: Opened ${url}`);
               break;
             default:
               actionHistory.push(`Attempt ${attempt + 1}: Unknown action ${action}`);
@@ -2639,7 +2381,7 @@ I'm stuck. What should I do next? Be specific about what to click or type.`;
         } catch (e) {
           actionHistory.push(`Attempt ${attempt + 1}: Action failed - ${e}`);
         }
-        await sleep(2e3);
+        await sleep2(2e3);
       }
       step.result = `\u{1F3AF} Adaptive Agent Result:
 
@@ -2687,7 +2429,7 @@ async function executeTask(task, onProgress) {
   task.completedAt = /* @__PURE__ */ new Date();
   return task;
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function getTaskMemoryStats() {
@@ -2702,8 +2444,8 @@ function getTaskMemoryStats() {
 }
 function clearTaskMemory() {
   try {
-    if (fs3.existsSync(TASK_MEMORY_FILE)) {
-      fs3.unlinkSync(TASK_MEMORY_FILE);
+    if (fs2.existsSync(TASK_MEMORY_FILE)) {
+      fs2.unlinkSync(TASK_MEMORY_FILE);
     }
   } catch {
   }