@projectservan8n/cnapse 0.8.2 → 0.10.0

package/dist/index.js

@@ -1,12 +1,59 @@
 #!/usr/bin/env node
 import {
-  ProviderSelector,
+  ProviderSelector
+} from "./chunk-7SDY7OPA.js";
+import {
+  askAI,
+  getPageText,
+  googleDocsType,
+  googleSheetsType,
+  openGoogleDoc,
+  openGoogleSheet,
+  openUrl,
+  research,
+  scroll,
+  sendGmail,
+  sendOutlook,
+  webSearch
+} from "./chunk-MOKGR7WE.js";
+import {
+  chat,
+  chatWithVision
+} from "./chunk-GP73OJCZ.js";
+import {
+  clickMouse,
+  closeWindow,
+  doubleClick,
+  findAndClick,
+  focusWindow,
+  getActiveWindow,
+  getMousePosition,
+  keyCombo,
+  listDir,
+  listWindows,
+  maximizeWindow,
+  minimizeWindow,
+  moveMouse,
+  pressKey,
+  readFile,
+  restoreWindow,
+  runCommand,
+  scrollMouse,
+  typeText,
+  typeTextHuman,
+  writeFile
+} from "./chunk-TFHK5CYF.js";
+import {
+  captureScreenshot,
+  describeScreen
+} from "./chunk-OIVTPXE4.js";
+import {
   getApiKey,
   getConfig,
   setApiKey,
   setModel,
   setProvider
-} from "./chunk-OPX7FFL6.js";
+} from "./chunk-COKO6V5J.js";
 
 // src/index.tsx
 import { render } from "ink";
@@ -194,580 +241,6 @@ function HelpMenu({ onClose, onSelect }) {
 
 // src/hooks/useChat.ts
 import { useState as useState2, useCallback, useRef, useEffect } from "react";
-
-// src/lib/system.ts
-import os from "os";
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
-var cachedSystemInfo = null;
-async function getSystemInfo() {
-  if (cachedSystemInfo) return cachedSystemInfo;
-  const platform = os.platform();
-  const cpus = os.cpus();
-  let osName = platform;
-  const osVersion = os.release();
-  if (platform === "win32") {
-    try {
-      const { stdout } = await execAsync("wmic os get Caption /value", { timeout: 5e3 });
-      const match = stdout.match(/Caption=(.+)/);
-      if (match) osName = match[1].trim();
-    } catch {
-      osName = `Windows ${osVersion}`;
-    }
-  } else if (platform === "darwin") {
-    try {
-      const { stdout } = await execAsync("sw_vers -productName && sw_vers -productVersion", { timeout: 5e3 });
-      const lines = stdout.trim().split("\n");
-      osName = `${lines[0]} ${lines[1]}`;
-    } catch {
-      osName = `macOS ${osVersion}`;
-    }
-  } else if (platform === "linux") {
-    try {
-      const { stdout } = await execAsync("cat /etc/os-release | grep PRETTY_NAME", { timeout: 5e3 });
-      const match = stdout.match(/PRETTY_NAME="(.+)"/);
-      if (match) osName = match[1];
-    } catch {
-      osName = `Linux ${osVersion}`;
-    }
-  }
-  cachedSystemInfo = {
-    platform,
-    osName,
-    osVersion,
-    arch: os.arch(),
-    cpuModel: cpus[0]?.model || "Unknown CPU",
-    cpuCores: cpus.length,
-    totalMemoryGB: Math.round(os.totalmem() / 1024 ** 3 * 10) / 10,
-    freeMemoryGB: Math.round(os.freemem() / 1024 ** 3 * 10) / 10,
-    username: os.userInfo().username,
-    hostname: os.hostname(),
-    homeDir: os.homedir(),
-    shell: process.env.SHELL || process.env.COMSPEC || "unknown"
-  };
-  return cachedSystemInfo;
-}
-async function getSystemContext() {
-  const info = await getSystemInfo();
-  return `SYSTEM INFO:
-- OS: ${info.osName} (${info.arch})
-- CPU: ${info.cpuModel} (${info.cpuCores} cores)
-- RAM: ${info.totalMemoryGB}GB total, ${info.freeMemoryGB}GB free
-- User: ${info.username}@${info.hostname}
-- Home: ${info.homeDir}
-- Shell: ${info.shell}`;
-}
-function getCwd() {
-  return process.cwd();
-}
-
-// src/lib/api.ts
-var BASE_PROMPT = `You are C-napse, an AI assistant for PC automation running on the user's desktop.
-You have access to their system and can help with coding, file management, shell commands, and more.
-
-When responding:
-- Be direct and practical
-- Use markdown formatting for code blocks
-- If asked to do something, explain what you'll do first
-- Give commands specific to the user's OS (use the system info below)
-- Be aware of the user's current working directory`;
-var systemContextCache = null;
-async function getSystemPrompt() {
-  if (!systemContextCache) {
-    systemContextCache = await getSystemContext();
-  }
-  const cwd = getCwd();
-  return `${BASE_PROMPT}
-
-${systemContextCache}
-- Current directory: ${cwd}`;
-}
-async function chat(messages, systemPrompt) {
-  const config = getConfig();
-  const finalPrompt = systemPrompt || await getSystemPrompt();
-  const allMessages = [
-    { role: "system", content: finalPrompt },
-    ...messages
-  ];
-  switch (config.provider) {
-    case "openrouter":
-      return chatOpenRouter(allMessages, config.model);
-    case "ollama":
-      return chatOllama(allMessages, config.model);
-    case "anthropic":
-      return chatAnthropic(allMessages, config.model);
-    case "openai":
-      return chatOpenAI(allMessages, config.model);
-    default:
-      throw new Error(`Unknown provider: ${config.provider}`);
-  }
-}
-async function chatOpenRouter(messages, model) {
-  const apiKey = getApiKey("openrouter");
-  if (!apiKey) {
-    throw new Error("OpenRouter API key not configured. Run: cnapse auth openrouter <key>");
-  }
-  const config = getConfig();
-  const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      "Authorization": `Bearer ${apiKey}`,
-      "Content-Type": "application/json",
-      "HTTP-Referer": config.openrouter.siteUrl,
-      "X-Title": config.openrouter.appName
-    },
-    body: JSON.stringify({
-      model,
-      messages,
-      max_tokens: 2048,
-      temperature: 0.7
-    })
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`OpenRouter error: ${response.status} - ${error}`);
-  }
-  const data = await response.json();
-  const content = data.choices?.[0]?.message?.content || "";
-  return { content, model };
-}
-async function chatOllama(messages, model) {
-  const config = getConfig();
-  const response = await fetch(`${config.ollamaHost}/api/chat`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      model,
-      messages,
-      stream: false
-    })
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`Ollama error: ${response.status} - ${error}`);
-  }
-  const data = await response.json();
-  const content = data.message?.content || "";
-  return { content, model };
-}
-async function chatAnthropic(messages, model) {
-  const apiKey = getApiKey("anthropic");
-  if (!apiKey) {
-    throw new Error("Anthropic API key not configured. Run: cnapse auth anthropic <key>");
-  }
-  const systemMsg = messages.find((m) => m.role === "system");
-  const chatMessages = messages.filter((m) => m.role !== "system");
-  const response = await fetch("https://api.anthropic.com/v1/messages", {
-    method: "POST",
-    headers: {
-      "x-api-key": apiKey,
-      "Content-Type": "application/json",
-      "anthropic-version": "2023-06-01"
-    },
-    body: JSON.stringify({
-      model,
-      max_tokens: 2048,
-      system: systemMsg?.content || "",
-      messages: chatMessages
-    })
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`Anthropic error: ${response.status} - ${error}`);
-  }
-  const data = await response.json();
-  const content = data.content?.[0]?.text || "";
-  return { content, model };
-}
-async function chatOpenAI(messages, model) {
-  const apiKey = getApiKey("openai");
-  if (!apiKey) {
-    throw new Error("OpenAI API key not configured. Run: cnapse auth openai <key>");
-  }
-  const response = await fetch("https://api.openai.com/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      "Authorization": `Bearer ${apiKey}`,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      model,
-      messages,
-      max_tokens: 2048,
-      temperature: 0.7
-    })
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`OpenAI error: ${response.status} - ${error}`);
-  }
-  const data = await response.json();
-  const content = data.choices?.[0]?.message?.content || "";
-  return { content, model };
-}
-async function chatWithVision(messages, screenshotBase64) {
-  const config = getConfig();
-  const systemPrompt = await getSystemPrompt();
-  const visionPrompt = systemPrompt + "\n\nYou can see the user's screen. Describe what you see and help them with their request.";
-  switch (config.provider) {
-    case "openrouter":
-      return chatWithVisionOpenRouter(messages, screenshotBase64, visionPrompt);
-    case "ollama":
-      return chatWithVisionOllama(messages, screenshotBase64, visionPrompt);
-    case "anthropic":
-      return chatWithVisionAnthropic(messages, screenshotBase64, visionPrompt);
-    case "openai":
-      return chatWithVisionOpenAI(messages, screenshotBase64, visionPrompt);
-    default:
-      throw new Error(`Vision not supported for provider: ${config.provider}`);
-  }
-}
-async function chatWithVisionOpenRouter(messages, screenshot, systemPrompt) {
-  const apiKey = getApiKey("openrouter");
-  if (!apiKey) throw new Error("OpenRouter API key not configured");
-  const config = getConfig();
-  let model = config.model;
-  if (!model.includes("gpt-5") && !model.includes("claude") && !model.includes("gemini")) {
-    model = "openai/gpt-5-nano";
-  }
-  const lastUserIdx = messages.length - 1;
-  const visionMessages = messages.map((m, i) => {
-    if (i === lastUserIdx && m.role === "user") {
-      return {
-        role: "user",
-        content: [
-          { type: "text", text: m.content },
-          { type: "image_url", image_url: { url: `data:image/png;base64,${screenshot}` } }
-        ]
-      };
-    }
-    return m;
-  });
-  const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      "Authorization": `Bearer ${apiKey}`,
-      "Content-Type": "application/json",
-      "HTTP-Referer": config.openrouter.siteUrl,
-      "X-Title": config.openrouter.appName
-    },
-    body: JSON.stringify({
-      model,
-      messages: [{ role: "system", content: systemPrompt }, ...visionMessages],
-      max_tokens: 2048
-    })
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`OpenRouter vision error: ${response.status} - ${error}`);
-  }
-  const data = await response.json();
-  return { content: data.choices?.[0]?.message?.content || "", model };
-}
-async function chatWithVisionOllama(messages, screenshot, systemPrompt) {
-  const config = getConfig();
-  const visionModels = ["llava", "llama3.2-vision", "bakllava"];
-  const model = visionModels.find((m) => config.model.includes(m)) || "llava";
-  const lastUserMsg = messages.filter((m) => m.role === "user").pop();
-  const response = await fetch(`${config.ollamaHost}/api/generate`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      model,
-      prompt: `${systemPrompt}
-
-User: ${lastUserMsg?.content || "What do you see?"}`,
-      images: [screenshot],
-      stream: false
-    })
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`Ollama vision error: ${error}`);
-  }
-  const data = await response.json();
-  return { content: data.response || "", model };
-}
-async function chatWithVisionAnthropic(messages, screenshot, systemPrompt) {
-  const apiKey = getApiKey("anthropic");
-  if (!apiKey) throw new Error("Anthropic API key not configured");
-  const chatMessages = messages.filter((m) => m.role !== "system");
-  const lastUserIdx = chatMessages.length - 1;
-  const visionMessages = chatMessages.map((m, i) => {
-    if (i === lastUserIdx && m.role === "user") {
-      return {
-        role: "user",
-        content: [
-          { type: "image", source: { type: "base64", media_type: "image/png", data: screenshot } },
-          { type: "text", text: m.content }
-        ]
-      };
-    }
-    return { role: m.role, content: m.content };
-  });
-  const response = await fetch("https://api.anthropic.com/v1/messages", {
-    method: "POST",
-    headers: {
-      "x-api-key": apiKey,
-      "anthropic-version": "2023-06-01",
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      model: "claude-3-5-sonnet-20241022",
-      max_tokens: 2048,
-      system: systemPrompt,
-      messages: visionMessages
-    })
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`Anthropic vision error: ${error}`);
-  }
-  const data = await response.json();
-  return { content: data.content?.[0]?.text || "", model: "claude-3-5-sonnet-20241022" };
-}
-async function chatWithVisionOpenAI(messages, screenshot, systemPrompt) {
-  const apiKey = getApiKey("openai");
-  if (!apiKey) throw new Error("OpenAI API key not configured");
-  const lastUserIdx = messages.length - 1;
-  const visionMessages = messages.map((m, i) => {
-    if (i === lastUserIdx && m.role === "user") {
-      return {
-        role: "user",
-        content: [
-          { type: "text", text: m.content },
-          { type: "image_url", image_url: { url: `data:image/png;base64,${screenshot}` } }
-        ]
-      };
-    }
-    return m;
-  });
-  const response = await fetch("https://api.openai.com/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      "Authorization": `Bearer ${apiKey}`,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      model: "gpt-4o",
-      messages: [{ role: "system", content: systemPrompt }, ...visionMessages],
-      max_tokens: 2048
-    })
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`OpenAI vision error: ${error}`);
-  }
-  const data = await response.json();
-  return { content: data.choices?.[0]?.message?.content || "", model: "gpt-4o" };
-}
-
-// src/lib/vision.ts
-async function describeScreen() {
-  const screenshot = await captureScreenshot();
-  if (!screenshot) {
-    throw new Error("Failed to capture screenshot");
-  }
-  const config = getConfig();
-  const description = await analyzeWithVision(screenshot, config.provider);
-  return { description, screenshot };
-}
-async function captureScreenshot() {
-  try {
-    const screenshotDesktop = await import("screenshot-desktop");
-    const buffer = await screenshotDesktop.default({ format: "png" });
-    return buffer.toString("base64");
-  } catch {
-    return captureScreenFallback();
-  }
-}
-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 { readFile: readFile2, unlink } = await import("fs/promises");
-  const execAsync5 = promisify5(exec5);
-  const tempFile = join4(tmpdir(), `cnapse-screen-${Date.now()}.png`);
-  try {
-    const platform = process.platform;
-    if (platform === "win32") {
-      await execAsync5(`
-        Add-Type -AssemblyName System.Windows.Forms
-        $screen = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
-        $bitmap = New-Object System.Drawing.Bitmap($screen.Width, $screen.Height)
-        $graphics = [System.Drawing.Graphics]::FromImage($bitmap)
-        $graphics.CopyFromScreen($screen.Location, [System.Drawing.Point]::Empty, $screen.Size)
-        $bitmap.Save("${tempFile.replace(/\\/g, "\\\\")}")
-        $graphics.Dispose()
-        $bitmap.Dispose()
-      `, { shell: "powershell.exe" });
-    } else if (platform === "darwin") {
-      await execAsync5(`screencapture -x "${tempFile}"`);
-    } else {
-      await execAsync5(`gnome-screenshot -f "${tempFile}" 2>/dev/null || scrot "${tempFile}" 2>/dev/null || import -window root "${tempFile}"`);
-    }
-    const imageBuffer = await readFile2(tempFile);
-    await unlink(tempFile).catch(() => {
-    });
-    return imageBuffer.toString("base64");
-  } catch {
-    return null;
-  }
-}
-async function analyzeWithVision(base64Image, provider) {
-  const prompt = `Look at this screenshot and describe:
-1. What application or window is visible
-2. Key UI elements you can see (buttons, text fields, menus)
-3. What the user appears to be doing or could do next
-4. Any notable content or state
-
-Be concise but helpful.`;
-  switch (provider) {
-    case "ollama":
-      return analyzeWithOllama(base64Image, prompt);
-    case "openrouter":
-      return analyzeWithOpenRouter(base64Image, prompt);
-    case "anthropic":
-      return analyzeWithAnthropic(base64Image, prompt);
-    case "openai":
-      return analyzeWithOpenAI(base64Image, prompt);
-    default:
-      throw new Error(`Vision not supported for provider: ${provider}`);
-  }
-}
-async function analyzeWithOllama(base64Image, prompt) {
-  const config = getConfig();
-  const ollamaHost = config.ollamaHost || "http://localhost:11434";
-  const visionModels = ["llava", "llama3.2-vision", "bakllava", "llava-llama3"];
-  const model = visionModels.find((m) => config.model.includes(m)) || "llava";
-  const response = await fetch(`${ollamaHost}/api/generate`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      model,
-      prompt,
-      images: [base64Image],
-      stream: false
-    })
-  });
-  if (!response.ok) {
-    const text = await response.text();
-    throw new Error(`Ollama vision error: ${text}`);
-  }
-  const data = await response.json();
-  return data.response || "Unable to analyze image";
-}
-async function analyzeWithOpenRouter(base64Image, prompt) {
-  const apiKey = getApiKey("openrouter");
-  if (!apiKey) throw new Error("OpenRouter API key not configured");
-  const model = "anthropic/claude-3-5-sonnet";
-  const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      "Authorization": `Bearer ${apiKey}`,
-      "Content-Type": "application/json",
-      "HTTP-Referer": "https://c-napse.up.railway.app",
-      "X-Title": "C-napse"
-    },
-    body: JSON.stringify({
-      model,
-      messages: [
-        {
-          role: "user",
-          content: [
-            { type: "text", text: prompt },
-            {
-              type: "image_url",
-              image_url: { url: `data:image/png;base64,${base64Image}` }
-            }
-          ]
-        }
-      ],
-      max_tokens: 1e3
-    })
-  });
-  if (!response.ok) {
-    const text = await response.text();
-    throw new Error(`OpenRouter vision error: ${text}`);
-  }
-  const data = await response.json();
-  return data.choices?.[0]?.message?.content || "Unable to analyze image";
-}
-async function analyzeWithAnthropic(base64Image, prompt) {
-  const apiKey = getApiKey("anthropic");
-  if (!apiKey) throw new Error("Anthropic API key not configured");
-  const response = await fetch("https://api.anthropic.com/v1/messages", {
-    method: "POST",
-    headers: {
-      "x-api-key": apiKey,
-      "anthropic-version": "2023-06-01",
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      model: "claude-3-5-sonnet-20241022",
-      max_tokens: 1e3,
-      messages: [
-        {
-          role: "user",
-          content: [
-            {
-              type: "image",
-              source: {
-                type: "base64",
-                media_type: "image/png",
-                data: base64Image
-              }
-            },
-            { type: "text", text: prompt }
-          ]
-        }
-      ]
-    })
-  });
-  if (!response.ok) {
-    const text = await response.text();
-    throw new Error(`Anthropic vision error: ${text}`);
-  }
-  const data = await response.json();
-  return data.content?.[0]?.text || "Unable to analyze image";
-}
-async function analyzeWithOpenAI(base64Image, prompt) {
-  const apiKey = getApiKey("openai");
-  if (!apiKey) throw new Error("OpenAI API key not configured");
-  const response = await fetch("https://api.openai.com/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      "Authorization": `Bearer ${apiKey}`,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      model: "gpt-4-vision-preview",
-      messages: [
-        {
-          role: "user",
-          content: [
-            { type: "text", text: prompt },
-            {
-              type: "image_url",
-              image_url: { url: `data:image/png;base64,${base64Image}` }
-            }
-          ]
-        }
-      ],
-      max_tokens: 1e3
-    })
-  });
-  if (!response.ok) {
-    const text = await response.text();
-    throw new Error(`OpenAI vision error: ${text}`);
-  }
-  const data = await response.json();
-  return data.choices?.[0]?.message?.content || "Unable to analyze image";
-}
-
-// src/hooks/useChat.ts
 var WELCOME_MESSAGE = {
   id: "0",
   role: "system",
@@ -810,1028 +283,100 @@ function useChat(screenWatch = false) {
       timestamp: /* @__PURE__ */ new Date(),
       isStreaming: true
     };
-    setMessages((prev) => [...prev, userMsg, assistantMsg]);
-    setIsProcessing(true);
-    try {
-      const apiMessages = messages.filter((m) => m.role === "user" || m.role === "assistant").slice(-10).map((m) => ({ role: m.role, content: m.content }));
-      apiMessages.push({ role: "user", content });
-      let response;
-      if (screenWatchRef.current) {
-        const screenshot = await captureScreenshot();
-        if (screenshot) {
-          response = await chatWithVision(apiMessages, screenshot);
-        } else {
-          response = await chat(apiMessages);
-        }
-      } else {
-        response = await chat(apiMessages);
-      }
-      setMessages(
-        (prev) => prev.map(
-          (m) => m.id === assistantId ? { ...m, content: response.content || "(no response)", isStreaming: false } : m
-        )
-      );
-    } catch (err2) {
-      const errorMsg = err2 instanceof Error ? err2.message : "Unknown error";
-      setError(errorMsg);
-      setMessages(
-        (prev) => prev.map(
-          (m) => m.id === assistantId ? { ...m, content: `Error: ${errorMsg}`, isStreaming: false } : m
-        )
-      );
-    } finally {
-      setIsProcessing(false);
-    }
-  }, [messages, isProcessing]);
-  const clearMessages = useCallback(() => {
-    setMessages([WELCOME_MESSAGE]);
-    setError(null);
-  }, []);
-  return {
-    messages,
-    isProcessing,
-    error,
-    sendMessage,
-    addSystemMessage,
-    clearMessages
-  };
-}
-
-// src/hooks/useVision.ts
-import { useState as useState3, useCallback as useCallback2 } from "react";
-function useVision() {
-  const [isAnalyzing, setIsAnalyzing] = useState3(false);
-  const [lastDescription, setLastDescription] = useState3(null);
-  const [lastScreenshot, setLastScreenshot] = useState3(null);
-  const [error, setError] = useState3(null);
-  const analyze = useCallback2(async () => {
-    setIsAnalyzing(true);
-    setError(null);
-    try {
-      const result = await describeScreen();
-      setLastDescription(result.description);
-      setLastScreenshot(result.screenshot);
-      return result.description;
-    } catch (err2) {
-      const errorMsg = err2 instanceof Error ? err2.message : "Vision analysis failed";
-      setError(errorMsg);
-      throw err2;
-    } finally {
-      setIsAnalyzing(false);
-    }
-  }, []);
-  return {
-    isAnalyzing,
-    lastDescription,
-    lastScreenshot,
-    error,
-    analyze
-  };
-}
-
-// src/hooks/useTelegram.ts
-import { useState as useState4, useCallback as useCallback3, useEffect as useEffect2, useRef as useRef2 } from "react";
-
-// src/services/telegram.ts
-import { EventEmitter } from "events";
-
-// src/tools/shell.ts
-import { exec as exec4 } from "child_process";
-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) {
-  try {
-    const content = await fs.readFile(path3, "utf-8");
-    return ok(content);
-  } catch (error) {
-    return err(`Failed to read file: ${error.message}`);
-  }
-}
-async function writeFile(path3, content) {
-  try {
-    const dir = dirname(path3);
-    await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(path3, content, "utf-8");
-    return ok(`Written ${content.length} bytes to ${path3}`);
-  } catch (error) {
-    return err(`Failed to write file: ${error.message}`);
-  }
-}
-async function listDir(path3, recursive = false) {
-  try {
-    const stat = await fs.stat(path3);
-    if (!stat.isDirectory()) {
-      return err(`Not a directory: ${path3}`);
-    }
-    const entries = [];
-    async function walkDir(dir, prefix) {
-      const items = await fs.readdir(dir, { withFileTypes: true });
-      for (const item of items) {
-        const displayPath = prefix ? `${prefix}/${item.name}` : item.name;
-        if (item.isDirectory()) {
-          entries.push(`${displayPath}/`);
-          if (recursive) {
-            await walkDir(join(dir, item.name), displayPath);
-          }
-        } else {
-          entries.push(displayPath);
-        }
-      }
-    }
-    await walkDir(path3, "");
-    entries.sort();
-    return ok(entries.join("\n"));
-  } catch (error) {
-    return err(`Failed to list directory: ${error.message}`);
-  }
-}
-
-// src/tools/clipboard.ts
-import clipboardy from "clipboardy";
-
-// src/tools/process.ts
-import { exec as exec2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var execAsync2 = promisify2(exec2);
-
-// src/tools/computer.ts
-import { exec as exec3 } from "child_process";
-import { promisify as promisify3 } from "util";
-var execAsync3 = promisify3(exec3);
-async function moveMouse(x, y) {
-  try {
-    if (process.platform === "win32") {
-      await execAsync3(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point(${x}, ${y})"`, { shell: "cmd.exe" });
-    } else if (process.platform === "darwin") {
-      await execAsync3(`cliclick m:${x},${y}`);
-    } else {
-      await execAsync3(`xdotool mousemove ${x} ${y}`);
-    }
-    return ok(`Mouse moved to (${x}, ${y})`);
-  } catch (error) {
-    return err(`Failed to move mouse: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-async function clickMouse(button = "left") {
-  try {
-    if (process.platform === "win32") {
-      const script = `
-Add-Type -MemberDefinition @"
-[DllImport("user32.dll",CharSet=CharSet.Auto,CallingConvention=CallingConvention.StdCall)]
-public static extern void mouse_event(long dwFlags, long dx, long dy, long cButtons, long dwExtraInfo);
-"@ -Name Mouse -Namespace Win32
-${button === "left" ? "[Win32.Mouse]::mouse_event(0x02, 0, 0, 0, 0); [Win32.Mouse]::mouse_event(0x04, 0, 0, 0, 0)" : button === "right" ? "[Win32.Mouse]::mouse_event(0x08, 0, 0, 0, 0); [Win32.Mouse]::mouse_event(0x10, 0, 0, 0, 0)" : "[Win32.Mouse]::mouse_event(0x20, 0, 0, 0, 0); [Win32.Mouse]::mouse_event(0x40, 0, 0, 0, 0)"}`;
-      await execAsync3(`powershell -Command "${script.replace(/\n/g, " ")}"`, { shell: "cmd.exe" });
-    } else if (process.platform === "darwin") {
-      await execAsync3(`cliclick c:.`);
-    } else {
-      const btn = button === "left" ? "1" : button === "right" ? "3" : "2";
-      await execAsync3(`xdotool click ${btn}`);
-    }
-    return ok(`Clicked ${button} button`);
-  } catch (error) {
-    return err(`Failed to click: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-async function doubleClick() {
-  try {
-    if (process.platform === "win32") {
-      const script = `
-Add-Type -MemberDefinition @"
-[DllImport("user32.dll",CharSet=CharSet.Auto,CallingConvention=CallingConvention.StdCall)]
-public static extern void mouse_event(long dwFlags, long dx, long dy, long cButtons, long dwExtraInfo);
-"@ -Name Mouse -Namespace Win32
-[Win32.Mouse]::mouse_event(0x02, 0, 0, 0, 0); [Win32.Mouse]::mouse_event(0x04, 0, 0, 0, 0)
-Start-Sleep -Milliseconds 50
-[Win32.Mouse]::mouse_event(0x02, 0, 0, 0, 0); [Win32.Mouse]::mouse_event(0x04, 0, 0, 0, 0)`;
-      await execAsync3(`powershell -Command "${script.replace(/\n/g, " ")}"`, { shell: "cmd.exe" });
-    } else if (process.platform === "darwin") {
-      await execAsync3(`cliclick dc:.`);
-    } else {
-      await execAsync3(`xdotool click --repeat 2 --delay 50 1`);
-    }
-    return ok("Double clicked");
-  } catch (error) {
-    return err(`Failed to double click: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-async function typeText(text) {
-  try {
-    if (process.platform === "win32") {
-      const escapedText = text.replace(/'/g, "''").replace(/[+^%~(){}[\]]/g, "{$&}");
-      await execAsync3(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${escapedText}')"`, { shell: "cmd.exe" });
-    } else if (process.platform === "darwin") {
-      const escaped = text.replace(/'/g, "'\\''");
-      await execAsync3(`osascript -e 'tell application "System Events" to keystroke "${escaped}"'`);
-    } else {
-      const escaped = text.replace(/'/g, "'\\''");
-      await execAsync3(`xdotool type '${escaped}'`);
-    }
-    return ok(`Typed: ${text}`);
-  } catch (error) {
-    return err(`Failed to type: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-async function pressKey(key) {
-  try {
-    if (process.platform === "win32") {
-      const winKeyMap = {
-        "enter": "{ENTER}",
-        "return": "{ENTER}",
-        "escape": "{ESC}",
-        "esc": "{ESC}",
-        "tab": "{TAB}",
-        "space": " ",
-        "backspace": "{BACKSPACE}",
-        "delete": "{DELETE}",
-        "up": "{UP}",
-        "down": "{DOWN}",
-        "left": "{LEFT}",
-        "right": "{RIGHT}",
-        "home": "{HOME}",
-        "end": "{END}",
-        "pageup": "{PGUP}",
-        "pagedown": "{PGDN}",
-        "f1": "{F1}",
-        "f2": "{F2}",
-        "f3": "{F3}",
-        "f4": "{F4}",
-        "f5": "{F5}",
-        "f6": "{F6}",
-        "f7": "{F7}",
-        "f8": "{F8}",
-        "f9": "{F9}",
-        "f10": "{F10}",
-        "f11": "{F11}",
-        "f12": "{F12}"
-      };
-      const winKey = winKeyMap[key.toLowerCase()] || key;
-      await execAsync3(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${winKey}')"`, { shell: "cmd.exe" });
-    } else if (process.platform === "darwin") {
-      const macKeyMap = {
-        "return": 36,
-        "enter": 36,
-        "escape": 53,
-        "esc": 53,
-        "tab": 48,
-        "space": 49,
-        "backspace": 51,
-        "delete": 117,
-        "up": 126,
-        "down": 125,
-        "left": 123,
-        "right": 124
-      };
-      const keyCode = macKeyMap[key.toLowerCase()];
-      if (keyCode) {
-        await execAsync3(`osascript -e 'tell application "System Events" to key code ${keyCode}'`);
-      } else {
-        await execAsync3(`osascript -e 'tell application "System Events" to keystroke "${key}"'`);
-      }
-    } else {
-      await execAsync3(`xdotool key ${key}`);
-    }
-    return ok(`Pressed: ${key}`);
-  } catch (error) {
-    return err(`Failed to press key: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-async function keyCombo(keys) {
-  try {
-    if (process.platform === "win32") {
-      const hasWin = keys.some((k) => k.toLowerCase() === "meta" || k.toLowerCase() === "win");
-      const hasR = keys.some((k) => k.toLowerCase() === "r");
-      if (hasWin && hasR) {
-        await execAsync3(`powershell -Command "$shell = New-Object -ComObject WScript.Shell; $shell.Run('explorer shell:::{2559a1f3-21d7-11d4-bdaf-00c04f60b9f0}')"`, { shell: "cmd.exe" });
-        return ok(`Pressed: ${keys.join("+")}`);
-      }
-      const modifierMap = {
-        "control": "^",
-        "ctrl": "^",
-        "alt": "%",
-        "shift": "+"
-      };
-      let combo = "";
-      const regularKeys = [];
-      for (const key of keys) {
-        const lower = key.toLowerCase();
-        if (modifierMap[lower]) {
-          combo += modifierMap[lower];
-        } else if (lower !== "meta" && lower !== "win") {
-          regularKeys.push(key.toLowerCase());
-        }
-      }
-      combo += regularKeys.join("");
-      await execAsync3(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${combo}')"`, { shell: "cmd.exe" });
-    } else if (process.platform === "darwin") {
-      const modifiers = keys.filter((k) => ["control", "ctrl", "alt", "shift", "command", "meta"].includes(k.toLowerCase()));
-      const regular = keys.filter((k) => !["control", "ctrl", "alt", "shift", "command", "meta"].includes(k.toLowerCase()));
-      let cmd = 'tell application "System Events" to keystroke "' + regular.join("") + '"';
-      if (modifiers.length > 0) {
-        const modMap = {
-          "control": "control down",
-          "ctrl": "control down",
-          "alt": "option down",
-          "shift": "shift down",
-          "command": "command down",
-          "meta": "command down"
-        };
-        cmd += " using {" + modifiers.map((m) => modMap[m.toLowerCase()]).join(", ") + "}";
-      }
-      await execAsync3(`osascript -e '${cmd}'`);
-    } else {
-      await execAsync3(`xdotool key ${keys.join("+")}`);
-    }
-    return ok(`Pressed: ${keys.join("+")}`);
-  } catch (error) {
-    return err(`Failed to press combo: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-async function getActiveWindow() {
-  try {
-    if (process.platform === "win32") {
-      const script = `
-Add-Type @"
-using System;
-using System.Runtime.InteropServices;
-using System.Text;
-public class Win32 {
-    [DllImport("user32.dll")]
-    public static extern IntPtr GetForegroundWindow();
-    [DllImport("user32.dll")]
-    public static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int count);
-}
-"@
-$hwnd = [Win32]::GetForegroundWindow()
-$sb = New-Object System.Text.StringBuilder 256
-[Win32]::GetWindowText($hwnd, $sb, 256)
-$sb.ToString()`;
-      const { stdout } = await execAsync3(`powershell -Command "${script.replace(/\n/g, " ")}"`, { shell: "cmd.exe" });
-      return ok(stdout.trim() || "Unknown window");
-    } else if (process.platform === "darwin") {
-      const { stdout } = await execAsync3(`osascript -e 'tell application "System Events" to get name of first application process whose frontmost is true'`);
-      return ok(stdout.trim());
-    } else {
-      const { stdout } = await execAsync3(`xdotool getactivewindow getwindowname`);
-      return ok(stdout.trim());
-    }
-  } catch (error) {
-    return err(`Failed to get active window: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-async function listWindows() {
-  try {
-    if (process.platform === "win32") {
-      const { stdout } = await execAsync3(`powershell -Command "Get-Process | Where-Object {$_.MainWindowTitle} | Select-Object ProcessName, MainWindowTitle | Format-Table -AutoSize"`, { shell: "cmd.exe" });
-      return ok(stdout);
-    } else if (process.platform === "darwin") {
-      const { stdout } = await execAsync3(`osascript -e 'tell application "System Events" to get name of every application process whose visible is true'`);
-      return ok(stdout);
-    } else {
-      const { stdout } = await execAsync3(`wmctrl -l`);
-      return ok(stdout);
-    }
-  } catch (error) {
-    return err(`Failed to list windows: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-async function focusWindow(title) {
-  try {
-    if (process.platform === "win32") {
-      const escaped = title.replace(/'/g, "''");
-      await execAsync3(`powershell -Command "$wshell = New-Object -ComObject wscript.shell; $wshell.AppActivate('${escaped}')"`, { shell: "cmd.exe" });
-    } else if (process.platform === "darwin") {
-      await execAsync3(`osascript -e 'tell application "${title}" to activate'`);
-    } else {
-      await execAsync3(`wmctrl -a "${title}"`);
-    }
-    return ok(`Focused window: ${title}`);
-  } catch (error) {
-    return err(`Failed to focus window: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-async function minimizeWindow(title) {
-  try {
-    if (process.platform === "win32") {
-      if (title) {
-        const escaped = title.replace(/'/g, "''");
-        const script = `
-$proc = Get-Process | Where-Object { $_.MainWindowTitle -like '*${escaped}*' -and $_.MainWindowHandle -ne 0 } | Select-Object -First 1
-if ($proc) {
-    Add-Type @"
-    using System;
-    using System.Runtime.InteropServices;
-    public class Win32 {
-        [DllImport("user32.dll")]
-        public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
-    }
-"@
-    [Win32]::ShowWindow($proc.MainWindowHandle, 6)
-    Write-Output "Minimized: $($proc.MainWindowTitle)"
-} else {
-    Write-Output "NOT_FOUND"
-}`;
-        const { stdout } = await execAsync3(`powershell -Command "${script.replace(/\n/g, " ")}"`, { shell: "cmd.exe" });
-        if (stdout.includes("NOT_FOUND")) {
-          return err(`Window containing "${title}" not found`);
-        }
-        return ok(stdout.trim());
-      } else {
-        await execAsync3(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('% n')"`, { shell: "cmd.exe" });
-        return ok("Minimized active window");
-      }
-    } else if (process.platform === "darwin") {
-      if (title) {
-        await execAsync3(`osascript -e 'tell application "${title}" to set miniaturized of window 1 to true'`);
-      } else {
-        await execAsync3(`osascript -e 'tell application "System Events" to keystroke "m" using command down'`);
-      }
-      return ok(`Minimized window${title ? `: ${title}` : ""}`);
-    } else {
-      if (title) {
-        await execAsync3(`wmctrl -r "${title}" -b add,hidden`);
-      } else {
-        await execAsync3(`xdotool getactivewindow windowminimize`);
-      }
-      return ok(`Minimized window${title ? `: ${title}` : ""}`);
-    }
-  } catch (error) {
-    return err(`Failed to minimize window: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-async function maximizeWindow(title) {
-  try {
-    if (process.platform === "win32") {
-      if (title) {
-        const escaped = title.replace(/'/g, "''");
-        const script = `
-$proc = Get-Process | Where-Object { $_.MainWindowTitle -like '*${escaped}*' -and $_.MainWindowHandle -ne 0 } | Select-Object -First 1
-if ($proc) {
-    Add-Type @"
-    using System;
-    using System.Runtime.InteropServices;
-    public class Win32 {
-        [DllImport("user32.dll")]
-        public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
-    }
-"@
-    [Win32]::ShowWindow($proc.MainWindowHandle, 3)
-    Write-Output "Maximized: $($proc.MainWindowTitle)"
-} else {
-    Write-Output "NOT_FOUND"
-}`;
-        const { stdout } = await execAsync3(`powershell -Command "${script.replace(/\n/g, " ")}"`, { shell: "cmd.exe" });
-        if (stdout.includes("NOT_FOUND")) {
-          return err(`Window containing "${title}" not found`);
-        }
-        return ok(stdout.trim());
-      } else {
-        await execAsync3(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('% x')"`, { shell: "cmd.exe" });
-        return ok("Maximized active window");
-      }
-    } else if (process.platform === "darwin") {
-      if (title) {
-        await execAsync3(`osascript -e 'tell application "${title}" to set zoomed of window 1 to true'`);
-      } else {
-        await execAsync3(`osascript -e 'tell application "System Events" to keystroke "f" using {control down, command down}'`);
-      }
-      return ok(`Maximized window${title ? `: ${title}` : ""}`);
-    } else {
-      if (title) {
-        await execAsync3(`wmctrl -r "${title}" -b add,maximized_vert,maximized_horz`);
-      } else {
-        await execAsync3(`wmctrl -r :ACTIVE: -b add,maximized_vert,maximized_horz`);
-      }
-      return ok(`Maximized window${title ? `: ${title}` : ""}`);
-    }
-  } catch (error) {
-    return err(`Failed to maximize window: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-async function closeWindow(title) {
-  try {
-    if (process.platform === "win32") {
-      if (title) {
-        const escaped = title.replace(/'/g, "''");
-        await execAsync3(`powershell -Command "Get-Process | Where-Object { $_.MainWindowTitle -like '*${escaped}*' } | ForEach-Object { $_.CloseMainWindow() }"`, { shell: "cmd.exe" });
-        return ok(`Closed window: ${title}`);
-      } else {
-        await execAsync3(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('%{F4}')"`, { shell: "cmd.exe" });
-        return ok("Closed active window");
-      }
-    } else if (process.platform === "darwin") {
-      if (title) {
-        await execAsync3(`osascript -e 'tell application "${title}" to close window 1'`);
-      } else {
-        await execAsync3(`osascript -e 'tell application "System Events" to keystroke "w" using command down'`);
-      }
-      return ok(`Closed window${title ? `: ${title}` : ""}`);
-    } else {
-      if (title) {
-        await execAsync3(`wmctrl -c "${title}"`);
-      } else {
-        await execAsync3(`xdotool getactivewindow windowclose`);
-      }
-      return ok(`Closed window${title ? `: ${title}` : ""}`);
-    }
-  } catch (error) {
-    return err(`Failed to close window: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-async function restoreWindow(title) {
-  try {
-    if (process.platform === "win32") {
-      const escaped = title.replace(/'/g, "''");
-      const script = `
-$proc = Get-Process | Where-Object { $_.MainWindowTitle -like '*${escaped}*' -and $_.MainWindowHandle -ne 0 } | Select-Object -First 1
-if ($proc) {
-    Add-Type @"
-    using System;
-    using System.Runtime.InteropServices;
-    public class Win32 {
-        [DllImport("user32.dll")]
-        public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
-    }
-"@
-    [Win32]::ShowWindow($proc.MainWindowHandle, 9)
-    Write-Output "Restored: $($proc.MainWindowTitle)"
-} else {
-    Write-Output "NOT_FOUND"
-}`;
-      const { stdout } = await execAsync3(`powershell -Command "${script.replace(/\n/g, " ")}"`, { shell: "cmd.exe" });
-      if (stdout.includes("NOT_FOUND")) {
-        return err(`Window containing "${title}" not found`);
-      }
-      return ok(stdout.trim());
-    } else if (process.platform === "darwin") {
-      await execAsync3(`osascript -e 'tell application "${title}" to set miniaturized of window 1 to false'`);
-      return ok(`Restored window: ${title}`);
-    } else {
-      await execAsync3(`wmctrl -r "${title}" -b remove,hidden`);
-      return ok(`Restored window: ${title}`);
-    }
-  } catch (error) {
-    return err(`Failed to restore window: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-async function scrollMouse(amount) {
-  try {
-    if (process.platform === "win32") {
-      const direction = amount > 0 ? 120 * Math.abs(amount) : -120 * Math.abs(amount);
-      const script = `
-Add-Type -MemberDefinition @"
-[DllImport("user32.dll",CharSet=CharSet.Auto,CallingConvention=CallingConvention.StdCall)]
-public static extern void mouse_event(long dwFlags, long dx, long dy, long cButtons, long dwExtraInfo);
-"@ -Name Mouse -Namespace Win32
-[Win32.Mouse]::mouse_event(0x0800, 0, 0, ${direction}, 0)`;
-      await execAsync3(`powershell -Command "${script.replace(/\n/g, " ")}"`, { shell: "cmd.exe" });
-    } else if (process.platform === "darwin") {
-      const dir = amount > 0 ? "u" : "d";
-      await execAsync3(`cliclick -r ${dir}:${Math.abs(amount)}`);
-    } else {
-      const btn = amount > 0 ? "4" : "5";
-      await execAsync3(`xdotool click --repeat ${Math.abs(amount)} ${btn}`);
-    }
-    return ok(`Scrolled ${amount > 0 ? "up" : "down"} by ${Math.abs(amount)}`);
-  } catch (error) {
-    return err(`Failed to scroll: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-async function getMousePosition() {
-  try {
-    if (process.platform === "win32") {
-      const { stdout } = await execAsync3(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; $p = [System.Windows.Forms.Cursor]::Position; Write-Output \\"$($p.X),$($p.Y)\\""`, { shell: "cmd.exe" });
-      return ok(`Mouse position: ${stdout.trim()}`);
-    } else if (process.platform === "darwin") {
-      const { stdout } = await execAsync3(`cliclick p`);
-      return ok(`Mouse position: ${stdout.trim()}`);
-    } else {
-      const { stdout } = await execAsync3(`xdotool getmouselocation --shell`);
-      return ok(stdout);
-    }
-  } catch (error) {
-    return err(`Failed to get mouse position: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-
-// src/tools/index.ts
-function ok(output) {
-  return { success: true, output };
-}
-function err(error) {
-  return { success: false, output: "", error };
-}
-
-// src/tools/shell.ts
-var execAsync4 = promisify4(exec4);
-async function runCommand(cmd, timeout = 3e4) {
-  try {
-    const isWindows = process.platform === "win32";
-    const shell = isWindows ? "cmd.exe" : "/bin/sh";
-    const shellArg = isWindows ? "/C" : "-c";
-    const { stdout, stderr } = await execAsync4(cmd, {
-      shell,
-      timeout,
-      maxBuffer: 10 * 1024 * 1024
-      // 10MB
-    });
-    if (stderr && stderr.trim()) {
-      return ok(`${stdout}
-[stderr]: ${stderr}`);
-    }
-    return ok(stdout || "(no output)");
-  } catch (error) {
-    if (error.killed) {
-      return err(`Command timed out after ${timeout}ms`);
-    }
-    const stderr = error.stderr || "";
-    const stdout = error.stdout || "";
-    return {
-      success: false,
-      output: stdout,
-      error: `Exit code: ${error.code || -1}
-${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"
-        ]
-      });
-    } else {
-      context = await chromium.launchPersistentContext(userDataDir, {
-        headless: cfg.headless,
-        slowMo: cfg.slowMo,
-        viewport: cfg.viewport,
-        args: [
-          "--disable-blink-features=AutomationControlled"
-        ]
-      });
-    }
-  }
-  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 navigateTo(url) {
-  const page = await getPage();
-  await page.goto(url, { waitUntil: "domcontentloaded" });
-}
-async function takeScreenshot() {
-  const page = await getPage();
-  const buffer = await page.screenshot({ type: "png" });
-  return buffer.toString("base64");
-}
-async function clickElement(selector, timeout = 1e4) {
-  const page = await getPage();
-  try {
-    await page.click(selector, { timeout });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function typeInElement(selector, text, timeout = 1e4) {
-  const page = await getPage();
-  try {
-    await page.fill(selector, text, { timeout });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function pressKey2(key) {
-  const page = await getPage();
-  await page.keyboard.press(key);
-}
-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();
-  try {
-    const element = await page.$(selector);
-    return element !== null;
-  } 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 getFullAIResponse(site, maxScrolls = 5) {
-  const config = aiChatConfigs[site];
-  const page = await getPage();
-  const responseParts = [];
-  for (let i = 0; i < maxScrolls; i++) {
+    setMessages((prev) => [...prev, userMsg, assistantMsg]);
+    setIsProcessing(true);
     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());
+      const apiMessages = messages.filter((m) => m.role === "user" || m.role === "assistant").slice(-10).map((m) => ({ role: m.role, content: m.content }));
+      apiMessages.push({ role: "user", content });
+      let response;
+      if (screenWatchRef.current) {
+        const screenshot = await captureScreenshot();
+        if (screenshot) {
+          response = await chatWithVision(apiMessages, screenshot);
+        } else {
+          response = await chat(apiMessages);
         }
+      } else {
+        response = await chat(apiMessages);
       }
-      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;
+      setMessages(
+        (prev) => prev.map(
+          (m) => m.id === assistantId ? { ...m, content: response.content || "(no response)", isStreaming: false } : m
+        )
+      );
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : "Unknown error";
+      setError(errorMsg);
+      setMessages(
+        (prev) => prev.map(
+          (m) => m.id === assistantId ? { ...m, content: `Error: ${errorMsg}`, isStreaming: false } : m
+        )
+      );
+    } finally {
+      setIsProcessing(false);
     }
-  }
-  return responseParts;
-}
-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 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 googleSheetsType(cellData) {
-  const page = await getPage();
-  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);
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-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 });
-    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" }
+  }, [messages, isProcessing]);
+  const clearMessages = useCallback(() => {
+    setMessages([WELCOME_MESSAGE]);
+    setError(null);
+  }, []);
+  return {
+    messages,
+    isProcessing,
+    error,
+    sendMessage,
+    addSystemMessage,
+    clearMessages
   };
-  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++) {
+
+// src/hooks/useVision.ts
+import { useState as useState3, useCallback as useCallback2 } from "react";
+function useVision() {
+  const [isAnalyzing, setIsAnalyzing] = useState3(false);
+  const [lastDescription, setLastDescription] = useState3(null);
+  const [lastScreenshot, setLastScreenshot] = useState3(null);
+  const [error, setError] = useState3(null);
+  const analyze = useCallback2(async () => {
+    setIsAnalyzing(true);
+    setError(null);
     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;
+      const result = await describeScreen();
+      setLastDescription(result.description);
+      setLastScreenshot(result.screenshot);
+      return result.description;
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : "Vision analysis failed";
+      setError(errorMsg);
+      throw err;
+    } finally {
+      setIsAnalyzing(false);
     }
-  }
+  }, []);
   return {
-    query: topic,
-    sources,
-    summary: ""
-    // To be filled by AI
+    isAnalyzing,
+    lastDescription,
+    lastScreenshot,
+    error,
+    analyze
   };
 }
 
+// src/hooks/useTelegram.ts
+import { useState as useState4, useCallback as useCallback3, useEffect as useEffect2, useRef as useRef2 } from "react";
+
+// src/services/telegram.ts
+import { EventEmitter } from "events";
+
 // 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 fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var TASK_MEMORY_FILE = path.join(os.homedir(), ".cnapse", "task-memory.json");
 function loadTaskMemory() {
   try {
-    if (fs3.existsSync(TASK_MEMORY_FILE)) {
-      const data = fs3.readFileSync(TASK_MEMORY_FILE, "utf-8");
+    if (fs.existsSync(TASK_MEMORY_FILE)) {
+      const data = fs.readFileSync(TASK_MEMORY_FILE, "utf-8");
       return JSON.parse(data);
     }
   } catch {
@@ -1857,11 +402,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 (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
     }
-    fs3.writeFileSync(TASK_MEMORY_FILE, JSON.stringify(memory, null, 2));
+    fs.writeFileSync(TASK_MEMORY_FILE, JSON.stringify(memory, null, 2));
   } catch {
   }
 }
@@ -2348,31 +893,16 @@ ${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 openUrl(`https://${site}`);
+        await sleep(4e3);
+        await typeText(question);
+        await sleep(300);
+        await pressKey("Return");
         await sleep(5e3);
         const pageText = await getPageText();
         step.result = `\u{1F4DD} Response from ${site}:
@@ -2386,17 +916,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 +933,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 +944,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 openGoogleSheet();
           await sleep(5e3);
-          step.result = `\u{1F4CA} Created Google Sheet: ${sheetName}`;
+          step.result = `\u{1F4CA} Opened new Google Sheet: ${sheetName}`;
           break;
         }
         case "type": {
@@ -2436,13 +957,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 +972,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 sleep(5e3);
+          step.result = `\u{1F4C4} Opened new Google Doc: ${docName}`;
           break;
         }
         case "type": {
@@ -2473,15 +991,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 +1022,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": {
@@ -2539,116 +1051,206 @@ ${uiAnalysis.content}`;
     }
     case "adaptive_do": {
       const goal = params;
-      const maxAttempts = 5;
+      const maxAttempts = 25;
       const actionHistory = [];
       let accomplished = false;
-      const page = await getPage();
+      let stuckCount = 0;
+      const stuckThreshold = 3;
+      let lastScreenHash = "";
+      const { getLearner } = await import("./learner-KH3TFTD7.js");
+      const learner = getLearner();
+      await learner.load();
+      const initialScreen = await describeScreen();
+      const remembered = await learner.recall(goal, initialScreen.description);
+      if (remembered && remembered.successCount > remembered.failCount) {
+        actionHistory.push(`\u{1F4DA} Found remembered solution from ${remembered.source}`);
+      }
       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 currentHash = currentScreen.screenshot.slice(0, 1e3);
+        const screenChanged = currentHash !== lastScreenHash;
+        if (!screenChanged && attempt > 0) {
+          stuckCount++;
+        } else {
+          stuckCount = Math.max(0, stuckCount - 1);
+        }
+        lastScreenHash = currentHash;
         const nextAction = await chat([{
           role: "user",
           content: `GOAL: ${goal}
 
-CURRENT SCREEN: ${currentState.content}
+CURRENT SCREEN: ${currentScreen.description}
+
+PREVIOUS ACTIONS:
+${actionHistory.slice(-5).join("\n") || "None yet"}
 
-PREVIOUS ACTIONS TAKEN:
-${actionHistory.length > 0 ? actionHistory.join("\n") : "None yet"}
+ATTEMPT: ${attempt + 1}/${maxAttempts}
+STUCK COUNT: ${stuckCount} (will ask for help at ${stuckThreshold})
 
 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)
-- scroll: Scroll up/down
-- navigate: Go to URL
+
+Available actions:
+- click: Click at current mouse position
+- clickAt: Click at coordinates (VALUE: x,y)
+- moveTo: Move mouse to coordinates (VALUE: x,y)
+- type: Type text (VALUE: text to type)
+- press: Press a key (VALUE: Enter, Tab, Escape, etc.)
+- keyCombo: Key combination (VALUE: command+s, control+c, etc.)
+- scroll: Scroll (VALUE: up or down)
+- navigate: Open URL (VALUE: full URL)
+- wait: Wait for something to load (VALUE: seconds)
+- findClick: Find element and click it (VALUE: description of element)
 - done: Goal is accomplished
 - stuck: Can't figure out what to do
 
-Respond in format:
+Respond EXACTLY in this format:
 ACTION: <action_type>
-SELECTOR: <css selector or text to find>
-VALUE: <text to type or URL>
-REASONING: <why>`
+VALUE: <parameter>
+REASONING: <brief 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`);
+          actionHistory.push(`[${attempt + 1}] \u26A0\uFE0F 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;
-          actionHistory.push(`Attempt ${attempt + 1}: Goal accomplished!`);
+          actionHistory.push(`[${attempt + 1}] \u2705 Goal accomplished!`);
+          if (actionHistory.length > 1) {
+            const lastSuccessfulAction = actionHistory[actionHistory.length - 2];
+            const actionParts = lastSuccessfulAction.match(/→ (\w+)(?:\s*"(.+)")?/);
+            if (actionParts) {
+              await learner.learn(
+                currentScreen.description.slice(0, 300),
+                goal,
+                actionParts[1],
+                actionParts[2] || "",
+                "self"
+              );
+            }
+          }
           break;
         }
-        if (action === "stuck") {
-          actionHistory.push(`Attempt ${attempt + 1}: Got stuck, asking Perplexity for help...`);
-          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);
-          actionHistory.push(`Got advice: ${advice.response.slice(0, 200)}...`);
-          await navigateTo(page.url());
+        if (action === "stuck" || stuckCount >= stuckThreshold) {
+          actionHistory.push(`[${attempt + 1}] \u{1F198} Asking for help...`);
+          const suggestions = await learner.getHelp(
+            goal,
+            currentScreen.description,
+            actionHistory.slice(-3)
+          );
+          if (suggestions.length > 0) {
+            const suggestion = suggestions[0];
+            actionHistory.push(`\u{1F4A1} Got suggestion from ${suggestion.source}: ${suggestion.value.slice(0, 100)}`);
+            if (suggestion.action && suggestion.action !== "suggested") {
+              try {
+                await executeAdaptiveAction(suggestion.action, suggestion.value);
+                actionHistory.push(`[${attempt + 1}] \u2192 ${suggestion.action} "${suggestion.value.slice(0, 30)}"`);
+                await learner.learn(
+                  currentScreen.description.slice(0, 300),
+                  goal,
+                  suggestion.action,
+                  suggestion.value,
+                  suggestion.source
+                );
+                stuckCount = 0;
+              } catch (e) {
+                actionHistory.push(`[${attempt + 1}] \u274C Suggestion failed`);
+              }
+            }
+          } else {
+            actionHistory.push(`[${attempt + 1}] \u{1F615} No helpful suggestions found`);
+          }
           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}"`);
-              break;
-            case "type":
-              if (selector && value) {
-                const typed = await typeInElement(selector, value);
-                if (!typed) {
-                  await page.getByPlaceholder(selector).first().fill(value);
-                }
-              }
-              actionHistory.push(`Attempt ${attempt + 1}: Typed "${value}" in "${selector}"`);
-              break;
-            case "press":
-              await pressKey2(value || selector);
-              actionHistory.push(`Attempt ${attempt + 1}: Pressed ${value || selector}`);
-              break;
-            case "scroll":
-              await scroll(value.toLowerCase().includes("up") ? "up" : "down");
-              actionHistory.push(`Attempt ${attempt + 1}: Scrolled ${value || "down"}`);
-              break;
-            case "navigate":
-              const url = value.startsWith("http") ? value : `https://${value}`;
-              await navigateTo(url);
-              actionHistory.push(`Attempt ${attempt + 1}: Navigated to ${url}`);
-              break;
-            default:
-              actionHistory.push(`Attempt ${attempt + 1}: Unknown action ${action}`);
-          }
+          await executeAdaptiveAction(action, value);
+          actionHistory.push(`[${attempt + 1}] \u2192 ${action}${value ? ` "${value.slice(0, 40)}"` : ""}`);
         } catch (e) {
-          actionHistory.push(`Attempt ${attempt + 1}: Action failed - ${e}`);
+          actionHistory.push(`[${attempt + 1}] \u274C ${action} failed - ${e}`);
+          await learner.recordFailure(goal, action, value);
         }
-        await sleep(2e3);
+        await sleep(1e3 + Math.random() * 1e3);
       }
       step.result = `\u{1F3AF} Adaptive Agent Result:
 
 Goal: ${goal}
 Accomplished: ${accomplished ? "Yes \u2705" : "Partial/No \u274C"}
+Attempts: ${Math.min(actionHistory.length, maxAttempts)}/${maxAttempts}
 
 Action Log:
 ${actionHistory.join("\n")}`;
       break;
+      async function executeAdaptiveAction(action, value) {
+        switch (action) {
+          case "click":
+            await clickMouse("left");
+            break;
+          case "clickat":
+          case "clickAt": {
+            const [x, y] = value.split(",").map((n) => parseInt(n.trim()));
+            if (!isNaN(x) && !isNaN(y)) {
+              await moveMouse(x, y);
+              await sleep(100);
+              await clickMouse("left");
+            }
+            break;
+          }
+          case "moveto":
+          case "moveTo": {
+            const [mx, my] = value.split(",").map((n) => parseInt(n.trim()));
+            if (!isNaN(mx) && !isNaN(my)) {
+              await moveMouse(mx, my);
+            }
+            break;
+          }
+          case "type":
+            if (value) {
+              if (typeTextHuman) {
+                await typeTextHuman(value, 50);
+              } else {
+                await typeText(value);
+              }
+            }
+            break;
+          case "press":
+            await pressKey(value || "Return");
+            break;
+          case "keycombo":
+          case "keyCombo": {
+            const keys2 = value.split("+").map((k) => k.trim().toLowerCase());
+            await keyCombo(keys2);
+            break;
+          }
+          case "scroll":
+            await scroll(value.toLowerCase().includes("up") ? "up" : "down");
+            break;
+          case "navigate": {
+            const navUrl = value.startsWith("http") ? value : `https://${value}`;
+            await openUrl(navUrl);
+            await sleep(2e3);
+            break;
+          }
+          case "wait": {
+            const seconds2 = parseFloat(value) || 2;
+            await sleep(seconds2 * 1e3);
+            break;
+          }
+          case "findclick":
+          case "findClick":
+            if (findAndClick) {
+              await findAndClick(value);
+            } else {
+              throw new Error("findAndClick not available");
+            }
+            break;
+          default:
+            throw new Error(`Unknown action: ${action}`);
+        }
+      }
     }
     case "chat":
       step.result = `Task noted: ${params}`;
@@ -2702,8 +1304,8 @@ function getTaskMemoryStats() {
 }
 function clearTaskMemory() {
   try {
-    if (fs3.existsSync(TASK_MEMORY_FILE)) {
-      fs3.unlinkSync(TASK_MEMORY_FILE);
+    if (fs.existsSync(TASK_MEMORY_FILE)) {
+      fs.unlinkSync(TASK_MEMORY_FILE);
     }
   } catch {
   }
@@ -2803,6 +1405,7 @@ var TelegramBotService = class extends EventEmitter {
   isRunning = false;
   allowedChatIds = /* @__PURE__ */ new Set();
   chatHistory = /* @__PURE__ */ new Map();
+  watchIntervals = /* @__PURE__ */ new Map();
   constructor() {
     super();
   }
@@ -2861,18 +1464,24 @@ var TelegramBotService = class extends EventEmitter {
       await ctx.reply(
         `\u{1F916} C-napse connected!
 
-Commands:
+\u{1F4CB} Commands:
 /screen - Take screenshot
 /describe - Screenshot + AI description
 /task <desc> - Multi-step automation
 /run <cmd> - Execute shell command
 /status - System status
 
-Examples:
-\u2022 /task open folder E:/Test and list files
+\u{1F916} Autonomous Agent:
+/agent <goal> - Start autonomous agent
+/agent stop - Stop the agent
+/watch - Stream screen live
+/learn - View learned actions
+
+\u{1F4A1} Examples:
+\u2022 /agent open safari and search for weather
 \u2022 /task open notepad and type hello
+\u2022 /watch 10 (screenshot every 10s)
 \u2022 minimize chrome
-\u2022 what windows are open?
 
 Your chat ID: ${chatId}`
       );
@@ -2950,16 +1559,253 @@ ${result.error}
         return;
       }
       const config = getConfig();
+      let agentStatus = "Not running";
+      try {
+        const { getAutonomousAgent } = await import("./autonomous-VGEVIXXQ.js");
+        const agent = getAutonomousAgent();
+        const state = agent.getState();
+        if (state.isActive) {
+          agentStatus = `Running (${state.attemptCount} attempts, goal: ${state.goal?.slice(0, 30)}...)`;
+        }
+      } catch {
+      }
+      let learnedCount = 0;
+      try {
+        const { getLearner } = await import("./learner-KH3TFTD7.js");
+        const learner = getLearner();
+        const stats = learner.getStats();
+        learnedCount = stats.memorySize;
+      } catch {
+      }
       const status = [
         "\u{1F4CA} C-napse Status",
         "",
         `Provider: ${config.provider}`,
         `Model: ${config.model}`,
         `Platform: ${process.platform}`,
-        `Node: ${process.version}`
+        `Node: ${process.version}`,
+        "",
+        "\u{1F916} Agent Status:",
+        `  Agent: ${agentStatus}`,
+        `  Learned actions: ${learnedCount}`
       ].join("\n");
       await ctx.reply(status);
     });
+    this.bot.command("agent", async (ctx) => {
+      if (!this.isAllowed(ctx.chat.id)) {
+        await ctx.reply("\u26D4 Not authorized. Send /start first.");
+        return;
+      }
+      const args2 = ctx.message.text.replace("/agent", "").trim();
+      const { getAutonomousAgent } = await import("./autonomous-VGEVIXXQ.js");
+      const agent = getAutonomousAgent();
+      if (args2 === "stop") {
+        agent.stop();
+        await ctx.reply("\u{1F6D1} Agent stopped");
+        return;
+      }
+      if (args2 === "pause") {
+        agent.pause();
+        await ctx.reply("\u23F8\uFE0F Agent paused");
+        return;
+      }
+      if (args2 === "resume") {
+        agent.resume();
+        await ctx.reply("\u25B6\uFE0F Agent resumed");
+        return;
+      }
+      if (args2 === "status") {
+        const state = agent.getState();
+        const history = agent.getHistory().slice(-5);
+        let statusMsg = "\u{1F916} Agent Status\n\n";
+        statusMsg += `Goal: ${state.goal || "None"}
+`;
+        statusMsg += `Active: ${state.isActive ? "Yes" : "No"}
+`;
+        statusMsg += `Attempts: ${state.attemptCount}
+`;
+        statusMsg += `Confidence: ${state.confidence}%
+`;
+        statusMsg += `Stuck count: ${state.stuckCount}
+
+`;
+        if (history.length > 0) {
+          statusMsg += "Recent actions:\n";
+          history.forEach((h) => {
+            statusMsg += `\u2022 ${h.action}: ${h.value?.slice(0, 30) || ""} (${h.result})
+`;
+          });
+        }
+        await ctx.reply(statusMsg);
+        return;
+      }
+      if (!args2) {
+        await ctx.reply(
+          "\u{1F916} Autonomous Agent Commands:\n\n/agent <goal> - Start agent with a goal\n/agent stop - Stop the agent\n/agent pause - Pause the agent\n/agent resume - Resume the agent\n/agent status - Get agent status\n\nExamples:\n\u2022 /agent open safari and search for weather\n\u2022 /agent compose an email in gmail to john@test.com\n\u2022 /agent book a flight on kayak.com from NYC to LA"
+        );
+        return;
+      }
+      const goal = args2;
+      await ctx.reply(`\u{1F680} Starting agent with goal:
+"${goal}"
+
+Sending updates...`);
+      const chatId = ctx.chat.id;
+      let lastUpdate = Date.now();
+      let screenshotCount = 0;
+      const onAttempt = async (data) => {
+        if (Date.now() - lastUpdate < 3e3) return;
+        lastUpdate = Date.now();
+        await ctx.reply(`\u{1F504} Attempt ${data.count}/${data.max}`);
+      };
+      const onDecided = async (decision) => {
+        await ctx.reply(`\u{1F4AD} ${decision.action}: ${decision.value?.slice(0, 50) || ""}`);
+      };
+      const onCompleted = async (data) => {
+        const emoji = data.success ? "\u2705" : "\u274C";
+        await ctx.reply(`${emoji} Agent ${data.success ? "completed" : "stopped"} after ${data.attempts} attempts`);
+        try {
+          const screenshot = await captureScreenshot();
+          if (screenshot) {
+            const buffer = Buffer.from(screenshot, "base64");
+            await ctx.replyWithPhoto({ source: buffer }, {
+              caption: data.success ? "\u2705 Goal accomplished!" : "\u{1F4F8} Final state"
+            });
+          }
+        } catch {
+        }
+        agent.off("attempt", onAttempt);
+        agent.off("decided", onDecided);
+        agent.off("completed", onCompleted);
+        agent.off("error", onError);
+      };
+      const onError = async (data) => {
+        await ctx.reply(`\u274C Error: ${data.error}`);
+      };
+      const screenshotInterval = setInterval(async () => {
+        if (!agent.getState().isActive) {
+          clearInterval(screenshotInterval);
+          return;
+        }
+        screenshotCount++;
+        if (screenshotCount % 6 === 0) {
+          try {
+            const screenshot = await captureScreenshot();
+            if (screenshot) {
+              const buffer = Buffer.from(screenshot, "base64");
+              await ctx.replyWithPhoto({ source: buffer }, {
+                caption: `\u{1F4F8} Progress update (attempt ${agent.getState().attemptCount})`
+              });
+            }
+          } catch {
+          }
+        }
+      }, 5e3);
+      agent.on("attempt", onAttempt);
+      agent.on("decided", onDecided);
+      agent.on("completed", onCompleted);
+      agent.on("error", onError);
+      agent.start(goal).then((result) => {
+        clearInterval(screenshotInterval);
+      }).catch((err) => {
+        clearInterval(screenshotInterval);
+        ctx.reply(`\u274C Agent error: ${err.message}`);
+      });
+    });
+    this.bot.command("watch", async (ctx) => {
+      if (!this.isAllowed(ctx.chat.id)) {
+        await ctx.reply("\u26D4 Not authorized. Send /start first.");
+        return;
+      }
+      const args2 = ctx.message.text.replace("/watch", "").trim();
+      const chatId = ctx.chat.id;
+      if (args2 === "stop") {
+        if (this.watchIntervals?.has(chatId)) {
+          clearInterval(this.watchIntervals.get(chatId));
+          this.watchIntervals.delete(chatId);
+          await ctx.reply("\u{1F441}\uFE0F Screen streaming stopped");
+        } else {
+          await ctx.reply("Not currently streaming");
+        }
+        return;
+      }
+      const intervalSeconds = parseInt(args2) || 5;
+      const intervalMs = Math.max(3e3, Math.min(6e4, intervalSeconds * 1e3));
+      if (!this.watchIntervals) {
+        this.watchIntervals = /* @__PURE__ */ new Map();
+      }
+      if (this.watchIntervals.has(chatId)) {
+        clearInterval(this.watchIntervals.get(chatId));
+      }
+      await ctx.reply(`\u{1F441}\uFE0F Starting screen stream (every ${intervalMs / 1e3}s)
+Send /watch stop to end`);
+      try {
+        const screenshot = await captureScreenshot();
+        if (screenshot) {
+          const buffer = Buffer.from(screenshot, "base64");
+          await ctx.replyWithPhoto({ source: buffer }, { caption: "\u{1F4F8} Stream started" });
+        }
+      } catch {
+      }
+      const interval = setInterval(async () => {
+        try {
+          const screenshot = await captureScreenshot();
+          if (screenshot) {
+            const buffer = Buffer.from(screenshot, "base64");
+            await ctx.replyWithPhoto({ source: buffer }, {
+              caption: `\u{1F4F8} ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`
+            });
+          }
+        } catch {
+        }
+      }, intervalMs);
+      this.watchIntervals.set(chatId, interval);
+    });
+    this.bot.command("learn", async (ctx) => {
+      if (!this.isAllowed(ctx.chat.id)) {
+        await ctx.reply("\u26D4 Not authorized. Send /start first.");
+        return;
+      }
+      const args2 = ctx.message.text.replace("/learn", "").trim();
+      const { getLearner } = await import("./learner-KH3TFTD7.js");
+      const learner = getLearner();
+      await learner.load();
+      if (args2 === "clear") {
+        await learner.clearMemory();
+        await ctx.reply("\u{1F5D1}\uFE0F Learned actions cleared");
+        return;
+      }
+      if (args2 === "stats") {
+        const stats = learner.getStats();
+        await ctx.reply(
+          `\u{1F4CA} Learning Stats:
+
+Total learned: ${stats.memorySize}
+Total successes: ${stats.totalSuccesses}
+Total attempts: ${stats.totalAttempts}
+
+Sources:
+` + Object.entries(stats.sourceCounts).map(([source, count]) => `\u2022 ${source}: ${count}`).join("\n")
+        );
+        return;
+      }
+      const learned = learner.getAllLearned().slice(-10);
+      if (learned.length === 0) {
+        await ctx.reply("\u{1F4DA} No learned actions yet\n\nThe agent learns from successful actions and remembers them for next time.");
+        return;
+      }
+      let msg = "\u{1F4DA} Recent Learned Actions:\n\n";
+      learned.forEach((l, i) => {
+        msg += `${i + 1}. ${l.goal.slice(0, 40)}
+`;
+        msg += `   \u2192 ${l.actionType}: ${l.actionValue.slice(0, 30)}
+`;
+        msg += `   (${l.successCount}\u2705 ${l.failCount}\u274C from ${l.source})
+
+`;
+      });
+      await ctx.reply(msg);
+    });
     this.bot.command("task", async (ctx) => {
       if (!this.isAllowed(ctx.chat.id)) {
         await ctx.reply("\u26D4 Not authorized. Send /start first.");
@@ -3082,8 +1928,8 @@ ${result.error}
         this.emit("error", new Error(errorMsg));
       }
     });
-    this.bot.catch((err2) => {
-      this.emit("error", err2);
+    this.bot.catch((err) => {
+      this.emit("error", err);
     });
   }
   /**
@@ -3225,15 +2071,15 @@ function useTelegram(onMessage) {
         setLastMessage(msg);
         onMessageRef.current?.(msg);
       });
-      bot.on("error", (err2) => {
-        setError(err2.message);
+      bot.on("error", (err) => {
+        setError(err.message);
       });
       await bot.start();
       setIsEnabled(true);
-    } catch (err2) {
-      const errorMsg = err2 instanceof Error ? err2.message : "Failed to start Telegram bot";
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : "Failed to start Telegram bot";
       setError(errorMsg);
-      throw err2;
+      throw err;
     } finally {
       setIsStarting(false);
     }
@@ -3244,10 +2090,10 @@ function useTelegram(onMessage) {
       const bot = getTelegramBot();
       await bot.stop();
       setIsEnabled(false);
-    } catch (err2) {
-      const errorMsg = err2 instanceof Error ? err2.message : "Failed to stop Telegram bot";
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : "Failed to stop Telegram bot";
       setError(errorMsg);
-      throw err2;
+      throw err;
     }
   }, [isEnabled]);
   const toggle = useCallback3(async () => {
@@ -3288,10 +2134,10 @@ function useTasks(onProgress) {
       });
       setCurrentTask(result);
       return result;
-    } catch (err2) {
-      const errorMsg = err2 instanceof Error ? err2.message : "Task failed";
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : "Task failed";
       setError(errorMsg);
-      throw err2;
+      throw err;
     } finally {
       setIsRunning(false);
       setCurrentStep(null);
@@ -3433,7 +2279,7 @@ Type /help for commands`);
       chat2.addSystemMessage(`\u{1F5A5}\uFE0F Screen:
 
 ${description}`);
-    } catch (err2) {
+    } catch (err) {
       chat2.addSystemMessage(`\u274C ${vision.error || "Vision failed"}`);
     } finally {
       setStatus("Ready");
@@ -3589,7 +2435,7 @@ async function main() {
       case "config": {
         const subcommand = args[1];
         if (!subcommand) {
-          const { ProviderSelector: ProviderSelector2 } = await import("./ProviderSelector-MXRZFAOB.js");
+          const { ProviderSelector: ProviderSelector2 } = await import("./ProviderSelector-GZYF26LL.js");
           const { Box: Box7 } = await import("ink");
           render(
             /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsx7(
@@ -3705,7 +2551,7 @@ ${dim}GitHub: https://github.com/projectservan8n/C-napse${reset}
         process.exit(0);
       }
       case "init": {
-        const { ProviderSelector: ProviderSelector2 } = await import("./ProviderSelector-MXRZFAOB.js");
+        const { ProviderSelector: ProviderSelector2 } = await import("./ProviderSelector-GZYF26LL.js");
         const { Box: Box7, Text: Text7 } = await import("ink");
         render(
           /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", padding: 1, children: [