@projectservan8n/cnapse 0.9.0 → 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: join3 } = await import("path");
-  const { readFile: readFile2, unlink } = await import("fs/promises");
-  const execAsync5 = promisify5(exec5);
-  const tempFile = join3(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",
@@ -831,8 +304,8 @@ function useChat(screenWatch = false) {
           (m) => m.id === assistantId ? { ...m, content: response.content || "(no response)", isStreaming: false } : m
         )
       );
-    } catch (err2) {
-      const errorMsg = err2 instanceof Error ? err2.message : "Unknown error";
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : "Unknown error";
       setError(errorMsg);
       setMessages(
         (prev) => prev.map(
@@ -872,10 +345,10 @@ function useVision() {
       setLastDescription(result.description);
       setLastScreenshot(result.screenshot);
       return result.description;
-    } catch (err2) {
-      const errorMsg = err2 instanceof Error ? err2.message : "Vision analysis failed";
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : "Vision analysis failed";
       setError(errorMsg);
-      throw err2;
+      throw err;
     } finally {
       setIsAnalyzing(false);
     }
@@ -895,735 +368,15 @@ import { useState as useState4, useCallback as useCallback3, useEffect as useEff
 // 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(path2) {
-  try {
-    const content = await fs.readFile(path2, "utf-8");
-    return ok(content);
-  } catch (error) {
-    return err(`Failed to read file: ${error.message}`);
-  }
-}
-async function writeFile(path2, content) {
-  try {
-    const dir = dirname(path2);
-    await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(path2, content, "utf-8");
-    return ok(`Written ${content.length} bytes to ${path2}`);
-  } catch (error) {
-    return err(`Failed to write file: ${error.message}`);
-  }
-}
-async function listDir(path2, recursive = false) {
-  try {
-    const stat = await fs.stat(path2);
-    if (!stat.isDirectory()) {
-      return err(`Not a directory: ${path2}`);
-    }
-    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(path2, "");
-    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
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function openUrl(url) {
-  const fullUrl = url.startsWith("http") ? url : `https://${url}`;
-  try {
-    if (process.platform === "win32") {
-      await runCommand(`start "" "${fullUrl}"`, 5e3);
-    } else if (process.platform === "darwin") {
-      await runCommand(`open "${fullUrl}"`, 5e3);
-    } else {
-      await runCommand(`xdg-open "${fullUrl}"`, 5e3);
-    }
-    return { success: true };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to open URL"
-    };
-  }
-}
-async function searchGoogle(query) {
-  const searchUrl = `https://www.google.com/search?q=${encodeURIComponent(query)}`;
-  return openUrl(searchUrl);
-}
-async function webSearch(query, engine = "google") {
-  const urls = {
-    google: `https://www.google.com/search?q=${encodeURIComponent(query)}`,
-    bing: `https://www.bing.com/search?q=${encodeURIComponent(query)}`,
-    duckduckgo: `https://duckduckgo.com/?q=${encodeURIComponent(query)}`
-  };
-  await openUrl(urls[engine]);
-  await sleep(3e3);
-  const vision = await describeScreen();
-  return `\u{1F50D} Search results for "${query}":
-
-${vision.description}`;
-}
-async function askAI(site, question) {
-  const urls = {
-    perplexity: "https://www.perplexity.ai",
-    chatgpt: "https://chat.openai.com",
-    claude: "https://claude.ai",
-    copilot: "https://copilot.microsoft.com",
-    google: "https://www.google.com"
-  };
-  await openUrl(urls[site]);
-  await sleep(4e3);
-  await typeText(question);
-  await sleep(500);
-  await pressKey("Return");
-  await sleep(site === "google" ? 3e3 : 1e4);
-  const vision = await describeScreen();
-  return {
-    response: vision.description,
-    screenshot: vision.screenshot
-  };
-}
-async function openGmailCompose(to, subject, body) {
-  let url = "https://mail.google.com/mail/u/0/?fs=1&tf=cm";
-  if (to) url += `&to=${encodeURIComponent(to)}`;
-  if (subject) url += `&su=${encodeURIComponent(subject)}`;
-  if (body) url += `&body=${encodeURIComponent(body)}`;
-  const result = await openUrl(url);
-  return result.success;
-}
-async function sendGmail(email) {
-  try {
-    await openGmailCompose(email.to, email.subject, email.body);
-    await sleep(5e3);
-    await keyCombo(["control", "Return"]);
-    await sleep(2e3);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function openOutlookCompose(to, subject, body) {
-  let url = "https://outlook.office.com/mail/deeplink/compose?";
-  if (to) url += `to=${encodeURIComponent(to)}&`;
-  if (subject) url += `subject=${encodeURIComponent(subject)}&`;
-  if (body) url += `body=${encodeURIComponent(body)}&`;
-  const result = await openUrl(url);
-  return result.success;
-}
-async function sendOutlook(email) {
-  try {
-    await openOutlookCompose(email.to, email.subject, email.body);
-    await sleep(5e3);
-    await keyCombo(["control", "Return"]);
-    await sleep(2e3);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function openGoogleSheet() {
-  const result = await openUrl("https://docs.google.com/spreadsheets/create");
-  return result.success;
-}
-async function openGoogleDoc() {
-  const result = await openUrl("https://docs.google.com/document/create");
-  return result.success;
-}
-async function scroll(direction, amount = 3) {
-  const key = direction === "down" ? "pagedown" : "pageup";
-  for (let i = 0; i < amount; i++) {
-    await pressKey(key);
-    await sleep(200);
-  }
-}
-async function getPageText() {
-  const vision = await describeScreen();
-  return vision.description;
-}
-async function research(topic, maxSources = 3) {
-  await searchGoogle(topic);
-  await sleep(3e3);
-  const searchResults = await describeScreen();
-  return {
-    query: topic,
-    sources: [{
-      title: `Google search: ${topic}`,
-      url: `https://www.google.com/search?q=${encodeURIComponent(topic)}`,
-      content: searchResults.description
-    }],
-    summary: searchResults.description
-  };
-}
-async function googleSheetsType(cells) {
-  try {
-    for (const { cell, value } of cells) {
-      await keyCombo(["control", "g"]);
-      await sleep(500);
-      await typeText(cell);
-      await pressKey("Return");
-      await sleep(300);
-      await typeText(value);
-      await pressKey("Return");
-      await sleep(200);
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function googleDocsType(text) {
-  try {
-    await sleep(1e3);
-    await typeText(text);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // src/lib/tasks.ts
-import * as fs2 from "fs";
+import * as fs from "fs";
 import * as path from "path";
-import * as os2 from "os";
-var TASK_MEMORY_FILE = path.join(os2.homedir(), ".cnapse", "task-memory.json");
+import * as os from "os";
+var TASK_MEMORY_FILE = path.join(os.homedir(), ".cnapse", "task-memory.json");
 function loadTaskMemory() {
   try {
-    if (fs2.existsSync(TASK_MEMORY_FILE)) {
-      const data = fs2.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 {
@@ -1650,10 +403,10 @@ function saveTaskPattern(input, steps) {
     }
     memory.patterns = memory.patterns.sort((a, b) => b.successCount - a.successCount).slice(0, 100);
     const dir = path.dirname(TASK_MEMORY_FILE);
-    if (!fs2.existsSync(dir)) {
-      fs2.mkdirSync(dir, { recursive: true });
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
     }
-    fs2.writeFileSync(TASK_MEMORY_FILE, JSON.stringify(memory, null, 2));
+    fs.writeFileSync(TASK_MEMORY_FILE, JSON.stringify(memory, null, 2));
   } catch {
   }
 }
@@ -2004,9 +757,9 @@ async function executeStep(step) {
   switch (actionType) {
     case "open_app":
       await keyCombo(["meta", "r"]);
-      await sleep2(500);
+      await sleep(500);
       await typeText(params);
-      await sleep2(300);
+      await sleep(300);
       await pressKey("Return");
       step.result = `Opened ${params}`;
       break;
@@ -2030,7 +783,7 @@ async function executeStep(step) {
       break;
     case "wait":
       const seconds = parseInt(params) || 1;
-      await sleep2(seconds * 1e3);
+      await sleep(seconds * 1e3);
       step.result = `Waited ${seconds}s`;
       break;
     case "focus_window":
@@ -2146,11 +899,11 @@ ${existingResult.output}`;
 ${result.response}`;
       } else {
         await openUrl(`https://${site}`);
-        await sleep2(4e3);
+        await sleep(4e3);
         await typeText(question);
-        await sleep2(300);
+        await sleep(300);
         await pressKey("Return");
-        await sleep2(5e3);
+        await sleep(5e3);
         const pageText = await getPageText();
         step.result = `\u{1F4DD} Response from ${site}:
 
@@ -2192,7 +945,7 @@ ${pageText.slice(0, 3e3)}`;
         case "new": {
           const sheetName = sheetArgs[0] || "Untitled spreadsheet";
           await openGoogleSheet();
-          await sleep2(5e3);
+          await sleep(5e3);
           step.result = `\u{1F4CA} Opened new Google Sheet: ${sheetName}`;
           break;
         }
@@ -2220,7 +973,7 @@ ${vision2.description}`;
         case "new": {
           const docName = docArgs[0] || "Untitled document";
           await openGoogleDoc();
-          await sleep2(5e3);
+          await sleep(5e3);
           step.result = `\u{1F4C4} Opened new Google Doc: ${docName}`;
           break;
         }
@@ -2298,99 +1051,206 @@ ${uiAnalysis.content}`;
     }
     case "adaptive_do": {
       const goal = params;
-      const maxAttempts = 5;
+      const maxAttempts = 25;
       const actionHistory = [];
       let accomplished = false;
+      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 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: ${currentScreen.description}
 
-PREVIOUS ACTIONS TAKEN:
-${actionHistory.length > 0 ? actionHistory.join("\n") : "None yet"}
+PREVIOUS ACTIONS:
+${actionHistory.slice(-5).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 (will click at current mouse position)
-- type: Type something (specify text)
-- press: Press a key (specify key like Enter, Tab, Escape)
-- scroll: Scroll up/down
-- navigate: Go to URL (opens in browser)
+
+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>
-VALUE: <text to type, URL to navigate, or key to press>
-REASONING: <why>`
+VALUE: <parameter>
+REASONING: <brief why>`
         }]);
         const actionContent = nextAction.content;
         const actionMatch = actionContent.match(/ACTION:\s*(\w+)/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 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);
-          actionHistory.push(`Got advice: ${advice.response.slice(0, 200)}...`);
+        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":
-              await clickMouse("left");
-              actionHistory.push(`Attempt ${attempt + 1}: Clicked`);
-              break;
-            case "type":
-              if (value) {
-                await typeText(value);
-              }
-              actionHistory.push(`Attempt ${attempt + 1}: Typed "${value}"`);
-              break;
-            case "press":
-              await pressKey(value || "Return");
-              actionHistory.push(`Attempt ${attempt + 1}: Pressed ${value || "Enter"}`);
-              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 openUrl(url);
-              actionHistory.push(`Attempt ${attempt + 1}: Opened ${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 sleep2(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}`;
@@ -2429,7 +1289,7 @@ async function executeTask(task, onProgress) {
   task.completedAt = /* @__PURE__ */ new Date();
   return task;
 }
-function sleep2(ms) {
+function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function getTaskMemoryStats() {
@@ -2444,8 +1304,8 @@ function getTaskMemoryStats() {
 }
 function clearTaskMemory() {
   try {
-    if (fs2.existsSync(TASK_MEMORY_FILE)) {
-      fs2.unlinkSync(TASK_MEMORY_FILE);
+    if (fs.existsSync(TASK_MEMORY_FILE)) {
+      fs.unlinkSync(TASK_MEMORY_FILE);
     }
   } catch {
   }
@@ -2545,6 +1405,7 @@ var TelegramBotService = class extends EventEmitter {
   isRunning = false;
   allowedChatIds = /* @__PURE__ */ new Set();
   chatHistory = /* @__PURE__ */ new Map();
+  watchIntervals = /* @__PURE__ */ new Map();
   constructor() {
     super();
   }
@@ -2603,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}`
       );
@@ -2692,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.");
@@ -2824,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);
     });
   }
   /**
@@ -2967,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);
     }
@@ -2986,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 () => {
@@ -3030,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);
@@ -3175,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");
@@ -3331,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(
@@ -3447,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: [