@projectservan8n/cnapse 0.8.0 → 0.8.2

package/dist/index.js

@@ -586,10 +586,10 @@ async function captureScreenFallback() {
   const { exec: exec5 } = await import("child_process");
   const { promisify: promisify5 } = await import("util");
   const { tmpdir } = await import("os");
-  const { join: join3 } = await import("path");
+  const { join: join4 } = await import("path");
   const { readFile: readFile2, unlink } = await import("fs/promises");
   const execAsync5 = promisify5(exec5);
-  const tempFile = join3(tmpdir(), `cnapse-screen-${Date.now()}.png`);
+  const tempFile = join4(tmpdir(), `cnapse-screen-${Date.now()}.png`);
   try {
     const platform = process.platform;
     if (platform === "win32") {
@@ -902,29 +902,29 @@ import { promisify as promisify4 } from "util";
 // src/tools/filesystem.ts
 import { promises as fs } from "fs";
 import { join, dirname } from "path";
-async function readFile(path2) {
+async function readFile(path3) {
   try {
-    const content = await fs.readFile(path2, "utf-8");
+    const content = await fs.readFile(path3, "utf-8");
     return ok(content);
   } catch (error) {
     return err(`Failed to read file: ${error.message}`);
   }
 }
-async function writeFile(path2, content) {
+async function writeFile(path3, content) {
   try {
-    const dir = dirname(path2);
+    const dir = dirname(path3);
     await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(path2, content, "utf-8");
-    return ok(`Written ${content.length} bytes to ${path2}`);
+    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(path2, recursive = false) {
+async function listDir(path3, recursive = false) {
   try {
-    const stat = await fs.stat(path2);
+    const stat = await fs.stat(path3);
     if (!stat.isDirectory()) {
-      return err(`Not a directory: ${path2}`);
+      return err(`Not a directory: ${path3}`);
     }
     const entries = [];
     async function walkDir(dir, prefix) {
@@ -941,7 +941,7 @@ async function listDir(path2, recursive = false) {
         }
       }
     }
-    await walkDir(path2, "");
+    await walkDir(path3, "");
     entries.sort();
     return ok(entries.join("\n"));
   } catch (error) {
@@ -1458,648 +1458,235 @@ ${stderr}`
   }
 }
 
-// src/services/telegram.ts
-function formatForTelegram(text) {
-  const hasMarkdown = /[*_`\[\]()]/.test(text);
-  if (!hasMarkdown) {
-    return { text, parseMode: void 0 };
-  }
-  try {
-    let formatted = text;
-    const escapeChars = ["\\", "_", "*", "[", "]", "(", ")", "~", "`", ">", "#", "+", "-", "=", "|", "{", "}", ".", "!"];
-    const placeholders = [];
-    let placeholderIndex = 0;
-    formatted = formatted.replace(/```([\s\S]*?)```/g, (match, code) => {
-      const placeholder = `__CODEBLOCK_${placeholderIndex++}__`;
-      placeholders.push({ placeholder, original: "```" + code.replace(/\\/g, "\\\\") + "```" });
-      return placeholder;
-    });
-    formatted = formatted.replace(/`([^`]+)`/g, (match, code) => {
-      const placeholder = `__INLINECODE_${placeholderIndex++}__`;
-      placeholders.push({ placeholder, original: "`" + code.replace(/\\/g, "\\\\") + "`" });
-      return placeholder;
-    });
-    formatted = formatted.replace(/\*\*(.+?)\*\*/g, (match, text2) => {
-      const placeholder = `__BOLD_${placeholderIndex++}__`;
-      placeholders.push({ placeholder, original: "*" + text2 + "*" });
-      return placeholder;
-    });
-    formatted = formatted.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, (match, text2) => {
-      const placeholder = `__ITALIC_${placeholderIndex++}__`;
-      placeholders.push({ placeholder, original: "_" + text2 + "_" });
-      return placeholder;
-    });
-    formatted = formatted.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (match, text2, url) => {
-      const placeholder = `__LINK_${placeholderIndex++}__`;
-      placeholders.push({ placeholder, original: "[" + text2 + "](" + url + ")" });
-      return placeholder;
-    });
-    for (const char of escapeChars) {
-      if (char === "\\") continue;
-      formatted = formatted.split(char).join("\\" + char);
+// 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;
     }
-    for (const { placeholder, original } of placeholders) {
-      formatted = formatted.replace(placeholder, original);
+  }
+  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"
+        ]
+      });
     }
-    return { text: formatted, parseMode: "MarkdownV2" };
+  }
+  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 { text, parseMode: void 0 };
+    return false;
   }
 }
-async function sendFormattedMessage(ctx, text) {
-  const { text: formatted, parseMode } = formatForTelegram(text);
+async function typeInElement(selector, text, timeout = 1e4) {
+  const page = await getPage();
   try {
-    if (parseMode) {
-      await ctx.reply(formatted, { parse_mode: parseMode });
-    } else {
-      await ctx.reply(text);
-    }
+    await page.fill(selector, text, { timeout });
+    return true;
   } catch {
-    await ctx.reply(text);
+    return false;
   }
 }
-var TelegramBotService = class extends EventEmitter {
-  bot = null;
-  isRunning = false;
-  allowedChatIds = /* @__PURE__ */ new Set();
-  chatHistory = /* @__PURE__ */ new Map();
-  constructor() {
-    super();
+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;
   }
-  /**
-   * Start the Telegram bot
-   */
-  async start() {
-    if (this.isRunning) {
-      return;
-    }
-    const botToken = getApiKey("telegram");
-    if (!botToken) {
-      throw new Error("Telegram bot token not configured. Use: cnapse auth telegram YOUR_BOT_TOKEN");
+}
+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++) {
     try {
-      const { Telegraf } = await import("telegraf");
-      this.bot = new Telegraf(botToken);
-      const config = getConfig();
-      if (config.telegram?.chatId) {
-        this.allowedChatIds.add(config.telegram.chatId);
+      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());
+        }
       }
-      this.setupHandlers();
-      await this.bot.launch();
-      this.isRunning = true;
-      this.emit("started");
-    } catch (error) {
-      throw new Error(`Failed to start Telegram bot: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  }
-  /**
-   * Stop the Telegram bot
-   */
-  async stop() {
-    if (!this.isRunning || !this.bot) {
-      return;
-    }
-    this.bot.stop("SIGTERM");
-    this.isRunning = false;
-    this.bot = null;
-    this.emit("stopped");
-  }
-  /**
-   * Check if bot is running
-   */
-  get running() {
-    return this.isRunning;
-  }
-  /**
-   * Setup message and command handlers
-   */
-  setupHandlers() {
-    if (!this.bot) return;
-    this.bot.command("start", async (ctx) => {
-      const chatId = ctx.chat.id;
-      this.allowedChatIds.add(chatId);
-      await ctx.reply(
-        `\u{1F916} C-napse connected!
-
-Commands:
-/screen - Take screenshot
-/describe - Screenshot + AI description
-/run <cmd> - Execute command
-/status - System status
-
-Your chat ID: ${chatId}`
-      );
-    });
-    this.bot.command("screen", async (ctx) => {
-      if (!this.isAllowed(ctx.chat.id)) {
-        await ctx.reply("\u26D4 Not authorized. Send /start first.");
-        return;
-      }
-      await ctx.reply("\u{1F4F8} Taking screenshot...");
-      try {
-        const screenshot = await captureScreenshot();
-        if (!screenshot) {
-          await ctx.reply("\u274C Failed to capture screenshot");
-          return;
-        }
-        const buffer = Buffer.from(screenshot, "base64");
-        await ctx.replyWithPhoto({ source: buffer }, { caption: "\u{1F4F8} Current screen" });
-      } catch (error) {
-        await ctx.reply(`\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}`);
-      }
-    });
-    this.bot.command("describe", async (ctx) => {
-      if (!this.isAllowed(ctx.chat.id)) {
-        await ctx.reply("\u26D4 Not authorized. Send /start first.");
-        return;
-      }
-      await ctx.reply("\u{1F50D} Analyzing screen...");
-      try {
-        const result = await describeScreen();
-        const buffer = Buffer.from(result.screenshot, "base64");
-        const caption = `\u{1F5A5}\uFE0F Screen Analysis:
-
-${result.description}`.slice(0, 1024);
-        await ctx.replyWithPhoto({ source: buffer }, { caption });
-        if (result.description.length > 900) {
-          await ctx.reply(result.description);
-        }
-      } catch (error) {
-        await ctx.reply(`\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}`);
-      }
-    });
-    this.bot.command("run", async (ctx) => {
-      if (!this.isAllowed(ctx.chat.id)) {
-        await ctx.reply("\u26D4 Not authorized. Send /start first.");
-        return;
-      }
-      const cmd = ctx.message.text.replace("/run ", "").trim();
-      if (!cmd) {
-        await ctx.reply("Usage: /run <command>\nExample: /run dir");
-        return;
-      }
-      await ctx.reply(`\u2699\uFE0F Running: ${cmd}`);
-      try {
-        const result = await runCommand(cmd, 3e4);
-        if (result.success) {
-          const output = result.output.slice(0, 4e3) || "(no output)";
-          await ctx.reply(`\u2705 Output:
-\`\`\`
-${output}
-\`\`\``, { parse_mode: "Markdown" });
-        } else {
-          await ctx.reply(`\u274C Error:
-\`\`\`
-${result.error}
-\`\`\``, { parse_mode: "Markdown" });
-        }
-      } catch (error) {
-        await ctx.reply(`\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}`);
-      }
-    });
-    this.bot.command("status", async (ctx) => {
-      if (!this.isAllowed(ctx.chat.id)) {
-        await ctx.reply("\u26D4 Not authorized. Send /start first.");
-        return;
-      }
-      const config = getConfig();
-      const status = [
-        "\u{1F4CA} C-napse Status",
-        "",
-        `Provider: ${config.provider}`,
-        `Model: ${config.model}`,
-        `Platform: ${process.platform}`,
-        `Node: ${process.version}`
-      ].join("\n");
-      await ctx.reply(status);
-    });
-    this.bot.on("text", async (ctx) => {
-      if (!this.isAllowed(ctx.chat.id)) {
-        return;
-      }
-      if (ctx.message.text.startsWith("/")) {
-        return;
-      }
-      const chatId = ctx.chat.id;
-      const userText = ctx.message.text;
-      const from = ctx.from.username || ctx.from.first_name || "User";
-      const message = {
-        chatId,
-        text: userText,
-        from
-      };
-      this.emit("message", message);
-      if (!this.chatHistory.has(chatId)) {
-        this.chatHistory.set(chatId, []);
-      }
-      const history = this.chatHistory.get(chatId);
-      history.push({ role: "user", content: userText });
-      if (history.length > 10) {
-        history.splice(0, history.length - 10);
-      }
-      try {
-        await ctx.sendChatAction("typing");
-        const computerControlResult = await this.tryComputerControl(userText);
-        if (computerControlResult) {
-          await sendFormattedMessage(ctx, computerControlResult);
-          history.push({ role: "assistant", content: computerControlResult });
-          return;
-        }
-        const isVisionRequest = /screen|see|look|what('?s| is) (on|visible)|show me|screenshot/i.test(userText);
-        let response;
-        if (isVisionRequest) {
-          const screenshot = await captureScreenshot();
-          if (screenshot) {
-            response = await chatWithVision(history, screenshot);
-          } else {
-            response = await chat(history);
-          }
-        } else {
-          response = await chat(history);
-        }
-        history.push({ role: "assistant", content: response.content });
-        const responseText = response.content || "(no response)";
-        if (responseText.length > 4e3) {
-          const chunks = responseText.match(/.{1,4000}/gs) || [responseText];
-          for (const chunk of chunks) {
-            await sendFormattedMessage(ctx, chunk);
-          }
-        } else {
-          await sendFormattedMessage(ctx, responseText);
-        }
-      } catch (error) {
-        const errorMsg = error instanceof Error ? error.message : "Unknown error";
-        await ctx.reply(`\u274C Error: ${errorMsg}`);
-        this.emit("error", new Error(errorMsg));
-      }
-    });
-    this.bot.catch((err2) => {
-      this.emit("error", err2);
-    });
-  }
-  /**
-   * Check if chat is authorized
-   */
-  isAllowed(chatId) {
-    if (this.allowedChatIds.size === 0) {
-      return true;
-    }
-    return this.allowedChatIds.has(chatId);
-  }
-  /**
-   * Try to execute computer control commands directly
-   * Returns response string if handled, null if not a computer command
-   */
-  async tryComputerControl(text) {
-    const lower = text.toLowerCase();
-    let match = lower.match(/minimize\s+(?:the\s+)?(.+)/i);
-    if (match) {
-      const result = await minimizeWindow(match[1].trim());
-      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
-    }
-    match = lower.match(/maximize\s+(?:the\s+)?(.+)/i);
-    if (match) {
-      const result = await maximizeWindow(match[1].trim());
-      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
-    }
-    match = lower.match(/close\s+(?:the\s+)?(.+)/i);
-    if (match) {
-      const result = await closeWindow(match[1].trim());
-      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
-    }
-    match = lower.match(/restore\s+(?:the\s+)?(.+)/i);
-    if (match) {
-      const result = await restoreWindow(match[1].trim());
-      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
-    }
-    match = lower.match(/(?:focus|open|switch to)\s+(?:the\s+)?(.+)/i);
-    if (match) {
-      const result = await focusWindow(match[1].trim());
-      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
-    }
-    match = text.match(/type\s+["'](.+)["']/i);
-    if (match) {
-      const result = await typeText(match[1]);
-      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
-    }
-    match = lower.match(/press\s+(?:the\s+)?(\w+)/i);
-    if (match) {
-      const result = await pressKey(match[1]);
-      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
-    }
-    if (/^click$/i.test(lower) || /click\s+(?:the\s+)?mouse/i.test(lower)) {
-      const result = await clickMouse("left");
-      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
-    }
-    if (/right\s*click/i.test(lower)) {
-      const result = await clickMouse("right");
-      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
-    }
-    if (/double\s*click/i.test(lower)) {
-      const result = await doubleClick();
-      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
-    }
-    match = lower.match(/move\s+(?:the\s+)?mouse\s+(?:to\s+)?(\d+)[,\s]+(\d+)/i);
-    if (match) {
-      const result = await moveMouse(parseInt(match[1]), parseInt(match[2]));
-      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
-    }
-    match = lower.match(/scroll\s+(up|down)(?:\s+(\d+))?/i);
-    if (match) {
-      const amount = match[1] === "up" ? parseInt(match[2]) || 3 : -(parseInt(match[2]) || 3);
-      const result = await scrollMouse(amount);
-      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
-    }
-    if (/list\s+(?:all\s+)?windows/i.test(lower) || /what\s+windows/i.test(lower)) {
-      const result = await listWindows();
-      return result.success ? `\u{1F4CB} Open Windows:
-${result.output}` : `\u274C ${result.error}`;
-    }
-    if (/(?:active|current|focused)\s+window/i.test(lower) || /what\s+(?:window|app)/i.test(lower)) {
-      const result = await getActiveWindow();
-      return result.success ? `\u{1FA9F} Active: ${result.output}` : `\u274C ${result.error}`;
-    }
-    if (/mouse\s+position/i.test(lower) || /where.*mouse/i.test(lower)) {
-      const result = await getMousePosition();
-      return result.success ? `\u{1F5B1}\uFE0F ${result.output}` : `\u274C ${result.error}`;
-    }
-    return null;
-  }
-  /**
-   * Send a message to a specific chat
-   */
-  async sendMessage(chatId, text) {
-    if (!this.bot || !this.isRunning) {
-      throw new Error("Telegram bot is not running");
-    }
-    await this.bot.telegram.sendMessage(chatId, text);
-  }
-  /**
-   * Send a photo to a specific chat
-   */
-  async sendPhoto(chatId, base64Image, caption) {
-    if (!this.bot || !this.isRunning) {
-      throw new Error("Telegram bot is not running");
-    }
-    const buffer = Buffer.from(base64Image, "base64");
-    await this.bot.telegram.sendPhoto(chatId, { source: buffer }, { caption });
-  }
-};
-var instance = null;
-function getTelegramBot() {
-  if (!instance) {
-    instance = new TelegramBotService();
-  }
-  return instance;
-}
-
-// src/hooks/useTelegram.ts
-function useTelegram(onMessage) {
-  const [isEnabled, setIsEnabled] = useState4(false);
-  const [isStarting, setIsStarting] = useState4(false);
-  const [error, setError] = useState4(null);
-  const [lastMessage, setLastMessage] = useState4(null);
-  const onMessageRef = useRef2(onMessage);
-  useEffect2(() => {
-    onMessageRef.current = onMessage;
-  }, [onMessage]);
-  const start = useCallback3(async () => {
-    if (isEnabled) return;
-    setIsStarting(true);
-    setError(null);
-    try {
-      const bot = getTelegramBot();
-      bot.on("message", (msg) => {
-        setLastMessage(msg);
-        onMessageRef.current?.(msg);
-      });
-      bot.on("error", (err2) => {
-        setError(err2.message);
-      });
-      await bot.start();
-      setIsEnabled(true);
-    } catch (err2) {
-      const errorMsg = err2 instanceof Error ? err2.message : "Failed to start Telegram bot";
-      setError(errorMsg);
-      throw err2;
-    } finally {
-      setIsStarting(false);
-    }
-  }, [isEnabled]);
-  const stop = useCallback3(async () => {
-    if (!isEnabled) return;
-    try {
-      const bot = getTelegramBot();
-      await bot.stop();
-      setIsEnabled(false);
-    } catch (err2) {
-      const errorMsg = err2 instanceof Error ? err2.message : "Failed to stop Telegram bot";
-      setError(errorMsg);
-      throw err2;
-    }
-  }, [isEnabled]);
-  const toggle = useCallback3(async () => {
-    if (isEnabled) {
-      await stop();
-    } else {
-      await start();
-    }
-  }, [isEnabled, start, stop]);
-  return {
-    isEnabled,
-    isStarting,
-    error,
-    lastMessage,
-    toggle,
-    start,
-    stop
-  };
-}
-
-// src/hooks/useTasks.ts
-import { useState as useState5, useCallback as useCallback4 } from "react";
-
-// src/services/browser.ts
-import { chromium } from "playwright";
-var browser = null;
-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 }
-};
-async function initBrowser(config = {}) {
-  const cfg = { ...defaultConfig, ...config };
-  if (!browser) {
-    browser = await chromium.launch({
-      headless: cfg.headless,
-      slowMo: cfg.slowMo
-    });
-  }
-  if (!context) {
-    context = await browser.newContext({
-      viewport: cfg.viewport,
-      userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
-    });
-  }
-  if (!activePage) {
-    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++) {
-    try {
-      const elements = await page.$$(config.responseSelector);
-      if (elements.length > 0) {
-        const lastElement = elements[elements.length - 1];
-        const text = await lastElement.textContent();
-        if (text) {
-          responseParts.push(text.trim());
-        }
-      }
-      await page.mouse.wheel(0, 500);
-      await page.waitForTimeout(1e3);
-      const atBottom = await page.evaluate(() => {
-        return window.innerHeight + window.scrollY >= document.body.scrollHeight - 100;
-      });
-      if (atBottom) break;
-    } catch {
-      break;
+      await page.mouse.wheel(0, 500);
+      await page.waitForTimeout(1e3);
+      const atBottom = await page.evaluate(() => {
+        return window.innerHeight + window.scrollY >= document.body.scrollHeight - 100;
+      });
+      if (atBottom) break;
+    } catch {
+      break;
     }
   }
   return responseParts;
@@ -2237,14 +1824,14 @@ async function research(topic, maxSources = 3) {
 }
 
 // src/lib/tasks.ts
-import * as fs2 from "fs";
-import * as path from "path";
-import * as os2 from "os";
-var TASK_MEMORY_FILE = path.join(os2.homedir(), ".cnapse", "task-memory.json");
+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");
 function loadTaskMemory() {
   try {
-    if (fs2.existsSync(TASK_MEMORY_FILE)) {
-      const data = fs2.readFileSync(TASK_MEMORY_FILE, "utf-8");
+    if (fs3.existsSync(TASK_MEMORY_FILE)) {
+      const data = fs3.readFileSync(TASK_MEMORY_FILE, "utf-8");
       return JSON.parse(data);
     }
   } catch {
@@ -2270,11 +1857,11 @@ 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 });
+    const dir = path2.dirname(TASK_MEMORY_FILE);
+    if (!fs3.existsSync(dir)) {
+      fs3.mkdirSync(dir, { recursive: true });
     }
-    fs2.writeFileSync(TASK_MEMORY_FILE, JSON.stringify(memory, null, 2));
+    fs3.writeFileSync(TASK_MEMORY_FILE, JSON.stringify(memory, null, 2));
   } catch {
   }
 }
@@ -2902,256 +2489,787 @@ Create a well-organized summary with:
 3. Any notable facts or statistics
 4. Conclusion
 
-Be thorough but concise.`
-      }]);
-      step.result = `\u{1F52C} Research Summary: ${researchQuery}
+Be thorough but concise.`
+      }]);
+      step.result = `\u{1F52C} Research Summary: ${researchQuery}
+
+${synthesis.content}`;
+      break;
+    }
+    case "ask_llm": {
+      const [llmName, ...questionParts] = params.split("|");
+      const question = questionParts.join("|");
+      const currentScreen = await describeScreen();
+      const fullQuestion = `I'm looking at my screen and I need help. ${question}
+
+Here's what I see on my screen: ${currentScreen.description}`;
+      const supportedLLMs = ["perplexity", "chatgpt", "claude", "copilot"];
+      const llmLower = llmName.toLowerCase();
+      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;
+      step.result = `\u{1F916} ${llmName} says:
+
+${finalResponse}`;
+      break;
+    }
+    case "learn_ui": {
+      const uiScreen = await describeScreen();
+      const uiAnalysis = await chat([{
+        role: "user",
+        content: `Analyze this screenshot and identify all interactive UI elements. List:
+1. All clickable buttons and their likely functions
+2. Text input fields
+3. Menus and dropdowns
+4. Links
+5. Any keyboard shortcuts visible
+6. The main actions available in this interface
+
+Question: ${params}
+
+Be specific about locations (top-left, center, etc.) and what each element does.`
+      }]);
+      step.result = `\u{1F50D} UI Analysis:
+
+${uiAnalysis.content}`;
+      break;
+    }
+    case "adaptive_do": {
+      const goal = params;
+      const maxAttempts = 5;
+      const actionHistory = [];
+      let accomplished = false;
+      const page = await getPage();
+      for (let attempt = 0; attempt < maxAttempts && !accomplished; attempt++) {
+        const screenshot = await takeScreenshot();
+        const currentState = await chat([{
+          role: "user",
+          content: `Describe what you see on this screen. What app/website is it? What elements are visible?`
+        }]);
+        const nextAction = await chat([{
+          role: "user",
+          content: `GOAL: ${goal}
+
+CURRENT SCREEN: ${currentState.content}
+
+PREVIOUS ACTIONS TAKEN:
+${actionHistory.length > 0 ? actionHistory.join("\n") : "None yet"}
+
+Based on what you see, what's the SINGLE next action to take?
+Options:
+- click: Click element (describe CSS selector or visible text)
+- type: Type something (specify selector and text)
+- press: Press a key (specify key)
+- scroll: Scroll up/down
+- navigate: Go to URL
+- done: Goal is accomplished
+- stuck: Can't figure out what to do
+
+Respond in format:
+ACTION: <action_type>
+SELECTOR: <css selector or text to find>
+VALUE: <text to type or URL>
+REASONING: <why>`
+        }]);
+        const actionContent = nextAction.content;
+        const actionMatch = actionContent.match(/ACTION:\s*(\w+)/i);
+        const selectorMatch = actionContent.match(/SELECTOR:\s*(.+?)(?:\n|$)/i);
+        const valueMatch = actionContent.match(/VALUE:\s*(.+?)(?:\n|$)/i);
+        if (!actionMatch) {
+          actionHistory.push(`Attempt ${attempt + 1}: Couldn't parse action`);
+          continue;
+        }
+        const action = actionMatch[1].toLowerCase();
+        const selector = selectorMatch?.[1]?.trim() || "";
+        const value = valueMatch?.[1]?.trim() || "";
+        if (action === "done") {
+          accomplished = true;
+          actionHistory.push(`Attempt ${attempt + 1}: Goal accomplished!`);
+          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());
+          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}`);
+          }
+        } catch (e) {
+          actionHistory.push(`Attempt ${attempt + 1}: Action failed - ${e}`);
+        }
+        await sleep(2e3);
+      }
+      step.result = `\u{1F3AF} Adaptive Agent Result:
+
+Goal: ${goal}
+Accomplished: ${accomplished ? "Yes \u2705" : "Partial/No \u274C"}
 
-${synthesis.content}`;
+Action Log:
+${actionHistory.join("\n")}`;
       break;
     }
-    case "ask_llm": {
-      const [llmName, ...questionParts] = params.split("|");
-      const question = questionParts.join("|");
-      const currentScreen = await describeScreen();
-      const fullQuestion = `I'm looking at my screen and I need help. ${question}
-
-Here's what I see on my screen: ${currentScreen.description}`;
-      const supportedLLMs = ["perplexity", "chatgpt", "claude", "copilot"];
-      const llmLower = llmName.toLowerCase();
-      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;
-      step.result = `\u{1F916} ${llmName} says:
-
-${finalResponse}`;
+    case "chat":
+      step.result = `Task noted: ${params}`;
       break;
+    default:
+      throw new Error(`Unknown action: ${actionType}`);
+  }
+}
+async function executeTask(task, onProgress) {
+  task.status = "running";
+  for (const step of task.steps) {
+    if (task.status === "failed") {
+      step.status = "skipped";
+      continue;
     }
-    case "learn_ui": {
-      const uiScreen = await describeScreen();
-      const uiAnalysis = await chat([{
-        role: "user",
-        content: `Analyze this screenshot and identify all interactive UI elements. List:
-1. All clickable buttons and their likely functions
-2. Text input fields
-3. Menus and dropdowns
-4. Links
-5. Any keyboard shortcuts visible
-6. The main actions available in this interface
-
-Question: ${params}
+    step.status = "running";
+    onProgress?.(task, step);
+    try {
+      await executeStep(step);
+      step.status = "completed";
+    } catch (error) {
+      step.status = "failed";
+      step.error = error instanceof Error ? error.message : "Unknown error";
+      task.status = "failed";
+    }
+    onProgress?.(task, step);
+  }
+  if (task.status !== "failed") {
+    task.status = "completed";
+    const steps = task.steps.map((s) => ({
+      description: s.description,
+      action: s.action
+    }));
+    saveTaskPattern(task.description, steps);
+  }
+  task.completedAt = /* @__PURE__ */ new Date();
+  return task;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getTaskMemoryStats() {
+  const memory = loadTaskMemory();
+  const totalUses = memory.patterns.reduce((sum, p) => sum + p.successCount, 0);
+  const topPatterns = memory.patterns.sort((a, b) => b.successCount - a.successCount).slice(0, 5).map((p) => `"${p.input}" (${p.successCount}x)`);
+  return {
+    patternCount: memory.patterns.length,
+    totalUses,
+    topPatterns
+  };
+}
+function clearTaskMemory() {
+  try {
+    if (fs3.existsSync(TASK_MEMORY_FILE)) {
+      fs3.unlinkSync(TASK_MEMORY_FILE);
+    }
+  } catch {
+  }
+}
+function formatTask(task) {
+  const statusEmoji = {
+    pending: "\u23F3",
+    running: "\u{1F504}",
+    completed: "\u2705",
+    failed: "\u274C"
+  };
+  const stepStatusEmoji = {
+    pending: "\u25CB",
+    running: "\u25D0",
+    completed: "\u25CF",
+    failed: "\u2717",
+    skipped: "\u25CC"
+  };
+  let output = `${statusEmoji[task.status]} Task: ${task.description}
 
-Be specific about locations (top-left, center, etc.) and what each element does.`
-      }]);
-      step.result = `\u{1F50D} UI Analysis:
+`;
+  for (const step of task.steps) {
+    output += `  ${stepStatusEmoji[step.status]} ${step.description}`;
+    if (step.result) {
+      output += ` \u2192 ${step.result}`;
+    }
+    if (step.error) {
+      output += ` (Error: ${step.error})`;
+    }
+    output += "\n";
+  }
+  return output;
+}
 
-${uiAnalysis.content}`;
-      break;
+// src/services/telegram.ts
+function formatForTelegram(text) {
+  const hasMarkdown = /[*_`\[\]()]/.test(text);
+  if (!hasMarkdown) {
+    return { text, parseMode: void 0 };
+  }
+  try {
+    let formatted = text;
+    const escapeChars = ["\\", "_", "*", "[", "]", "(", ")", "~", "`", ">", "#", "+", "-", "=", "|", "{", "}", ".", "!"];
+    const placeholders = [];
+    let placeholderIndex = 0;
+    formatted = formatted.replace(/```([\s\S]*?)```/g, (match, code) => {
+      const placeholder = `__CODEBLOCK_${placeholderIndex++}__`;
+      placeholders.push({ placeholder, original: "```" + code.replace(/\\/g, "\\\\") + "```" });
+      return placeholder;
+    });
+    formatted = formatted.replace(/`([^`]+)`/g, (match, code) => {
+      const placeholder = `__INLINECODE_${placeholderIndex++}__`;
+      placeholders.push({ placeholder, original: "`" + code.replace(/\\/g, "\\\\") + "`" });
+      return placeholder;
+    });
+    formatted = formatted.replace(/\*\*(.+?)\*\*/g, (match, text2) => {
+      const placeholder = `__BOLD_${placeholderIndex++}__`;
+      placeholders.push({ placeholder, original: "*" + text2 + "*" });
+      return placeholder;
+    });
+    formatted = formatted.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, (match, text2) => {
+      const placeholder = `__ITALIC_${placeholderIndex++}__`;
+      placeholders.push({ placeholder, original: "_" + text2 + "_" });
+      return placeholder;
+    });
+    formatted = formatted.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (match, text2, url) => {
+      const placeholder = `__LINK_${placeholderIndex++}__`;
+      placeholders.push({ placeholder, original: "[" + text2 + "](" + url + ")" });
+      return placeholder;
+    });
+    for (const char of escapeChars) {
+      if (char === "\\") continue;
+      formatted = formatted.split(char).join("\\" + char);
     }
-    case "adaptive_do": {
-      const goal = params;
-      const maxAttempts = 5;
-      const actionHistory = [];
-      let accomplished = false;
-      const page = await getPage();
-      for (let attempt = 0; attempt < maxAttempts && !accomplished; attempt++) {
-        const screenshot = await takeScreenshot();
-        const currentState = await chat([{
-          role: "user",
-          content: `Describe what you see on this screen. What app/website is it? What elements are visible?`
-        }]);
-        const nextAction = await chat([{
-          role: "user",
-          content: `GOAL: ${goal}
+    for (const { placeholder, original } of placeholders) {
+      formatted = formatted.replace(placeholder, original);
+    }
+    return { text: formatted, parseMode: "MarkdownV2" };
+  } catch {
+    return { text, parseMode: void 0 };
+  }
+}
+async function sendFormattedMessage(ctx, text) {
+  const { text: formatted, parseMode } = formatForTelegram(text);
+  try {
+    if (parseMode) {
+      await ctx.reply(formatted, { parse_mode: parseMode });
+    } else {
+      await ctx.reply(text);
+    }
+  } catch {
+    await ctx.reply(text);
+  }
+}
+var TelegramBotService = class extends EventEmitter {
+  bot = null;
+  isRunning = false;
+  allowedChatIds = /* @__PURE__ */ new Set();
+  chatHistory = /* @__PURE__ */ new Map();
+  constructor() {
+    super();
+  }
+  /**
+   * Start the Telegram bot
+   */
+  async start() {
+    if (this.isRunning) {
+      return;
+    }
+    const botToken = getApiKey("telegram");
+    if (!botToken) {
+      throw new Error("Telegram bot token not configured. Use: cnapse auth telegram YOUR_BOT_TOKEN");
+    }
+    try {
+      const { Telegraf } = await import("telegraf");
+      this.bot = new Telegraf(botToken);
+      const config = getConfig();
+      if (config.telegram?.chatId) {
+        this.allowedChatIds.add(config.telegram.chatId);
+      }
+      this.setupHandlers();
+      await this.bot.launch();
+      this.isRunning = true;
+      this.emit("started");
+    } catch (error) {
+      throw new Error(`Failed to start Telegram bot: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Stop the Telegram bot
+   */
+  async stop() {
+    if (!this.isRunning || !this.bot) {
+      return;
+    }
+    this.bot.stop("SIGTERM");
+    this.isRunning = false;
+    this.bot = null;
+    this.emit("stopped");
+  }
+  /**
+   * Check if bot is running
+   */
+  get running() {
+    return this.isRunning;
+  }
+  /**
+   * Setup message and command handlers
+   */
+  setupHandlers() {
+    if (!this.bot) return;
+    this.bot.command("start", async (ctx) => {
+      const chatId = ctx.chat.id;
+      this.allowedChatIds.add(chatId);
+      await ctx.reply(
+        `\u{1F916} C-napse connected!
 
-CURRENT SCREEN: ${currentState.content}
+Commands:
+/screen - Take screenshot
+/describe - Screenshot + AI description
+/task <desc> - Multi-step automation
+/run <cmd> - Execute shell command
+/status - System status
 
-PREVIOUS ACTIONS TAKEN:
-${actionHistory.length > 0 ? actionHistory.join("\n") : "None yet"}
+Examples:
+\u2022 /task open folder E:/Test and list files
+\u2022 /task open notepad and type hello
+\u2022 minimize chrome
+\u2022 what windows are open?
 
-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
-- done: Goal is accomplished
-- stuck: Can't figure out what to do
+Your chat ID: ${chatId}`
+      );
+    });
+    this.bot.command("screen", async (ctx) => {
+      if (!this.isAllowed(ctx.chat.id)) {
+        await ctx.reply("\u26D4 Not authorized. Send /start first.");
+        return;
+      }
+      await ctx.reply("\u{1F4F8} Taking screenshot...");
+      try {
+        const screenshot = await captureScreenshot();
+        if (!screenshot) {
+          await ctx.reply("\u274C Failed to capture screenshot");
+          return;
+        }
+        const buffer = Buffer.from(screenshot, "base64");
+        await ctx.replyWithPhoto({ source: buffer }, { caption: "\u{1F4F8} Current screen" });
+      } catch (error) {
+        await ctx.reply(`\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    });
+    this.bot.command("describe", async (ctx) => {
+      if (!this.isAllowed(ctx.chat.id)) {
+        await ctx.reply("\u26D4 Not authorized. Send /start first.");
+        return;
+      }
+      await ctx.reply("\u{1F50D} Analyzing screen...");
+      try {
+        const result = await describeScreen();
+        const buffer = Buffer.from(result.screenshot, "base64");
+        const caption = `\u{1F5A5}\uFE0F Screen Analysis:
 
-Respond in format:
-ACTION: <action_type>
-SELECTOR: <css selector or text to find>
-VALUE: <text to type or URL>
-REASONING: <why>`
-        }]);
-        const actionContent = nextAction.content;
-        const actionMatch = actionContent.match(/ACTION:\s*(\w+)/i);
-        const selectorMatch = actionContent.match(/SELECTOR:\s*(.+?)(?:\n|$)/i);
-        const valueMatch = actionContent.match(/VALUE:\s*(.+?)(?:\n|$)/i);
-        if (!actionMatch) {
-          actionHistory.push(`Attempt ${attempt + 1}: Couldn't parse action`);
-          continue;
+${result.description}`.slice(0, 1024);
+        await ctx.replyWithPhoto({ source: buffer }, { caption });
+        if (result.description.length > 900) {
+          await ctx.reply(result.description);
         }
-        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!`);
-          break;
+      } catch (error) {
+        await ctx.reply(`\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    });
+    this.bot.command("run", async (ctx) => {
+      if (!this.isAllowed(ctx.chat.id)) {
+        await ctx.reply("\u26D4 Not authorized. Send /start first.");
+        return;
+      }
+      const cmd = ctx.message.text.replace("/run ", "").trim();
+      if (!cmd) {
+        await ctx.reply("Usage: /run <command>\nExample: /run dir");
+        return;
+      }
+      await ctx.reply(`\u2699\uFE0F Running: ${cmd}`);
+      try {
+        const result = await runCommand(cmd, 3e4);
+        if (result.success) {
+          const output = result.output.slice(0, 4e3) || "(no output)";
+          await ctx.reply(`\u2705 Output:
+\`\`\`
+${output}
+\`\`\``, { parse_mode: "Markdown" });
+        } else {
+          await ctx.reply(`\u274C Error:
+\`\`\`
+${result.error}
+\`\`\``, { parse_mode: "Markdown" });
         }
-        if (action === "stuck") {
-          actionHistory.push(`Attempt ${attempt + 1}: Got stuck, asking Perplexity for help...`);
-          const helpRequest = `I'm trying to: ${goal}
+      } catch (error) {
+        await ctx.reply(`\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    });
+    this.bot.command("status", async (ctx) => {
+      if (!this.isAllowed(ctx.chat.id)) {
+        await ctx.reply("\u26D4 Not authorized. Send /start first.");
+        return;
+      }
+      const config = getConfig();
+      const status = [
+        "\u{1F4CA} C-napse Status",
+        "",
+        `Provider: ${config.provider}`,
+        `Model: ${config.model}`,
+        `Platform: ${process.platform}`,
+        `Node: ${process.version}`
+      ].join("\n");
+      await ctx.reply(status);
+    });
+    this.bot.command("task", async (ctx) => {
+      if (!this.isAllowed(ctx.chat.id)) {
+        await ctx.reply("\u26D4 Not authorized. Send /start first.");
+        return;
+      }
+      const taskDescription = ctx.message.text.replace("/task", "").trim();
+      if (!taskDescription) {
+        await ctx.reply(
+          "\u{1F4CB} Usage: /task <description>\n\nExamples:\n\u2022 /task open notepad and type hello\n\u2022 /task open folder E:/Test and list files\n\u2022 /task search google for weather today\n\u2022 /task open chrome and go to github.com"
+        );
+        return;
+      }
+      await ctx.reply(`\u{1F3AF} Parsing task: "${taskDescription}"`);
+      try {
+        const task = await parseTask(taskDescription);
+        let stepsPreview = `\u{1F4CB} Task broken into ${task.steps.length} steps:
 
-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());
-          continue;
+`;
+        task.steps.forEach((step, i) => {
+          stepsPreview += `${i + 1}. ${step.description}
+`;
+        });
+        stepsPreview += "\n\u23F3 Executing...";
+        await ctx.reply(stepsPreview);
+        let lastUpdate = Date.now();
+        const updatedTask = await executeTask(task, async (t, step) => {
+          const now = Date.now();
+          if (now - lastUpdate > 2e3) {
+            lastUpdate = now;
+            const stepNum = t.steps.indexOf(step) + 1;
+            const status = step.status === "running" ? "\u{1F504}" : step.status === "completed" ? "\u2705" : "\u274C";
+            await ctx.sendChatAction("typing");
+          }
+        });
+        const result = formatTask(updatedTask);
+        if (result.length > 4e3) {
+          const chunks = result.match(/.{1,4000}/gs) || [result];
+          for (const chunk of chunks) {
+            await sendFormattedMessage(ctx, chunk);
+          }
+        } else {
+          await sendFormattedMessage(ctx, result);
         }
-        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}`);
+        const hasScreenStep = updatedTask.steps.some(
+          (s) => s.action.includes("screenshot") || s.action.includes("describe")
+        );
+        if (hasScreenStep || updatedTask.status === "completed") {
+          try {
+            const screenshot = await captureScreenshot();
+            if (screenshot) {
+              const buffer = Buffer.from(screenshot, "base64");
+              await ctx.replyWithPhoto({ source: buffer }, {
+                caption: updatedTask.status === "completed" ? "\u2705 Task completed - current screen" : "\u{1F4F8} Final screen state"
+              });
+            }
+          } catch {
           }
-        } catch (e) {
-          actionHistory.push(`Attempt ${attempt + 1}: Action failed - ${e}`);
         }
-        await sleep(2e3);
+      } catch (error) {
+        await ctx.reply(`\u274C Task failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    });
+    this.bot.on("text", async (ctx) => {
+      if (!this.isAllowed(ctx.chat.id)) {
+        return;
+      }
+      if (ctx.message.text.startsWith("/")) {
+        return;
+      }
+      const chatId = ctx.chat.id;
+      const userText = ctx.message.text;
+      const from = ctx.from.username || ctx.from.first_name || "User";
+      const message = {
+        chatId,
+        text: userText,
+        from
+      };
+      this.emit("message", message);
+      if (!this.chatHistory.has(chatId)) {
+        this.chatHistory.set(chatId, []);
+      }
+      const history = this.chatHistory.get(chatId);
+      history.push({ role: "user", content: userText });
+      if (history.length > 10) {
+        history.splice(0, history.length - 10);
+      }
+      try {
+        await ctx.sendChatAction("typing");
+        const computerControlResult = await this.tryComputerControl(userText);
+        if (computerControlResult) {
+          await sendFormattedMessage(ctx, computerControlResult);
+          history.push({ role: "assistant", content: computerControlResult });
+          return;
+        }
+        const isVisionRequest = /screen|see|look|what('?s| is) (on|visible)|show me|screenshot/i.test(userText);
+        let response;
+        if (isVisionRequest) {
+          const screenshot = await captureScreenshot();
+          if (screenshot) {
+            response = await chatWithVision(history, screenshot);
+          } else {
+            response = await chat(history);
+          }
+        } else {
+          response = await chat(history);
+        }
+        history.push({ role: "assistant", content: response.content });
+        const responseText = response.content || "(no response)";
+        if (responseText.length > 4e3) {
+          const chunks = responseText.match(/.{1,4000}/gs) || [responseText];
+          for (const chunk of chunks) {
+            await sendFormattedMessage(ctx, chunk);
+          }
+        } else {
+          await sendFormattedMessage(ctx, responseText);
+        }
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : "Unknown error";
+        await ctx.reply(`\u274C Error: ${errorMsg}`);
+        this.emit("error", new Error(errorMsg));
       }
-      step.result = `\u{1F3AF} Adaptive Agent Result:
-
-Goal: ${goal}
-Accomplished: ${accomplished ? "Yes \u2705" : "Partial/No \u274C"}
-
-Action Log:
-${actionHistory.join("\n")}`;
-      break;
+    });
+    this.bot.catch((err2) => {
+      this.emit("error", err2);
+    });
+  }
+  /**
+   * Check if chat is authorized
+   */
+  isAllowed(chatId) {
+    if (this.allowedChatIds.size === 0) {
+      return true;
     }
-    case "chat":
-      step.result = `Task noted: ${params}`;
-      break;
-    default:
-      throw new Error(`Unknown action: ${actionType}`);
+    return this.allowedChatIds.has(chatId);
   }
-}
-async function executeTask(task, onProgress) {
-  task.status = "running";
-  for (const step of task.steps) {
-    if (task.status === "failed") {
-      step.status = "skipped";
-      continue;
+  /**
+   * Try to execute computer control commands directly
+   * Returns response string if handled, null if not a computer command
+   */
+  async tryComputerControl(text) {
+    const lower = text.toLowerCase();
+    let match = lower.match(/minimize\s+(?:the\s+)?(.+)/i);
+    if (match) {
+      const result = await minimizeWindow(match[1].trim());
+      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
     }
-    step.status = "running";
-    onProgress?.(task, step);
-    try {
-      await executeStep(step);
-      step.status = "completed";
-    } catch (error) {
-      step.status = "failed";
-      step.error = error instanceof Error ? error.message : "Unknown error";
-      task.status = "failed";
+    match = lower.match(/maximize\s+(?:the\s+)?(.+)/i);
+    if (match) {
+      const result = await maximizeWindow(match[1].trim());
+      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
     }
-    onProgress?.(task, step);
+    match = lower.match(/close\s+(?:the\s+)?(.+)/i);
+    if (match) {
+      const result = await closeWindow(match[1].trim());
+      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
+    }
+    match = lower.match(/restore\s+(?:the\s+)?(.+)/i);
+    if (match) {
+      const result = await restoreWindow(match[1].trim());
+      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
+    }
+    const looksLikeTask = /\b(and|then|after|tell me|list|what|show|describe|check|find|search|create|write|type\s+.+\s+in)\b/i.test(text);
+    if (!looksLikeTask) {
+      match = lower.match(/(?:focus|open|switch to)\s+(?:the\s+)?(\w+(?:\s+\w+)?)/i);
+      if (match) {
+        const result = await focusWindow(match[1].trim());
+        return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
+      }
+    }
+    match = text.match(/type\s+["'](.+)["']/i);
+    if (match) {
+      const result = await typeText(match[1]);
+      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
+    }
+    match = lower.match(/press\s+(?:the\s+)?(\w+)/i);
+    if (match) {
+      const result = await pressKey(match[1]);
+      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
+    }
+    if (/^click$/i.test(lower) || /click\s+(?:the\s+)?mouse/i.test(lower)) {
+      const result = await clickMouse("left");
+      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
+    }
+    if (/right\s*click/i.test(lower)) {
+      const result = await clickMouse("right");
+      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
+    }
+    if (/double\s*click/i.test(lower)) {
+      const result = await doubleClick();
+      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
+    }
+    match = lower.match(/move\s+(?:the\s+)?mouse\s+(?:to\s+)?(\d+)[,\s]+(\d+)/i);
+    if (match) {
+      const result = await moveMouse(parseInt(match[1]), parseInt(match[2]));
+      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
+    }
+    match = lower.match(/scroll\s+(up|down)(?:\s+(\d+))?/i);
+    if (match) {
+      const amount = match[1] === "up" ? parseInt(match[2]) || 3 : -(parseInt(match[2]) || 3);
+      const result = await scrollMouse(amount);
+      return result.success ? `\u2705 ${result.output}` : `\u274C ${result.error}`;
+    }
+    if (/list\s+(?:all\s+)?windows/i.test(lower) || /what\s+windows/i.test(lower)) {
+      const result = await listWindows();
+      return result.success ? `\u{1F4CB} Open Windows:
+${result.output}` : `\u274C ${result.error}`;
+    }
+    if (/(?:active|current|focused)\s+window/i.test(lower) || /what\s+(?:window|app)/i.test(lower)) {
+      const result = await getActiveWindow();
+      return result.success ? `\u{1FA9F} Active: ${result.output}` : `\u274C ${result.error}`;
+    }
+    if (/mouse\s+position/i.test(lower) || /where.*mouse/i.test(lower)) {
+      const result = await getMousePosition();
+      return result.success ? `\u{1F5B1}\uFE0F ${result.output}` : `\u274C ${result.error}`;
+    }
+    return null;
   }
-  if (task.status !== "failed") {
-    task.status = "completed";
-    const steps = task.steps.map((s) => ({
-      description: s.description,
-      action: s.action
-    }));
-    saveTaskPattern(task.description, steps);
+  /**
+   * Send a message to a specific chat
+   */
+  async sendMessage(chatId, text) {
+    if (!this.bot || !this.isRunning) {
+      throw new Error("Telegram bot is not running");
+    }
+    await this.bot.telegram.sendMessage(chatId, text);
   }
-  task.completedAt = /* @__PURE__ */ new Date();
-  return task;
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function getTaskMemoryStats() {
-  const memory = loadTaskMemory();
-  const totalUses = memory.patterns.reduce((sum, p) => sum + p.successCount, 0);
-  const topPatterns = memory.patterns.sort((a, b) => b.successCount - a.successCount).slice(0, 5).map((p) => `"${p.input}" (${p.successCount}x)`);
-  return {
-    patternCount: memory.patterns.length,
-    totalUses,
-    topPatterns
-  };
-}
-function clearTaskMemory() {
-  try {
-    if (fs2.existsSync(TASK_MEMORY_FILE)) {
-      fs2.unlinkSync(TASK_MEMORY_FILE);
+  /**
+   * Send a photo to a specific chat
+   */
+  async sendPhoto(chatId, base64Image, caption) {
+    if (!this.bot || !this.isRunning) {
+      throw new Error("Telegram bot is not running");
     }
-  } catch {
+    const buffer = Buffer.from(base64Image, "base64");
+    await this.bot.telegram.sendPhoto(chatId, { source: buffer }, { caption });
+  }
+};
+var instance = null;
+function getTelegramBot() {
+  if (!instance) {
+    instance = new TelegramBotService();
   }
+  return instance;
 }
-function formatTask(task) {
-  const statusEmoji = {
-    pending: "\u23F3",
-    running: "\u{1F504}",
-    completed: "\u2705",
-    failed: "\u274C"
-  };
-  const stepStatusEmoji = {
-    pending: "\u25CB",
-    running: "\u25D0",
-    completed: "\u25CF",
-    failed: "\u2717",
-    skipped: "\u25CC"
-  };
-  let output = `${statusEmoji[task.status]} Task: ${task.description}
 
-`;
-  for (const step of task.steps) {
-    output += `  ${stepStatusEmoji[step.status]} ${step.description}`;
-    if (step.result) {
-      output += ` \u2192 ${step.result}`;
+// src/hooks/useTelegram.ts
+function useTelegram(onMessage) {
+  const [isEnabled, setIsEnabled] = useState4(false);
+  const [isStarting, setIsStarting] = useState4(false);
+  const [error, setError] = useState4(null);
+  const [lastMessage, setLastMessage] = useState4(null);
+  const onMessageRef = useRef2(onMessage);
+  useEffect2(() => {
+    onMessageRef.current = onMessage;
+  }, [onMessage]);
+  const start = useCallback3(async () => {
+    if (isEnabled) return;
+    setIsStarting(true);
+    setError(null);
+    try {
+      const bot = getTelegramBot();
+      bot.on("message", (msg) => {
+        setLastMessage(msg);
+        onMessageRef.current?.(msg);
+      });
+      bot.on("error", (err2) => {
+        setError(err2.message);
+      });
+      await bot.start();
+      setIsEnabled(true);
+    } catch (err2) {
+      const errorMsg = err2 instanceof Error ? err2.message : "Failed to start Telegram bot";
+      setError(errorMsg);
+      throw err2;
+    } finally {
+      setIsStarting(false);
     }
-    if (step.error) {
-      output += ` (Error: ${step.error})`;
+  }, [isEnabled]);
+  const stop = useCallback3(async () => {
+    if (!isEnabled) return;
+    try {
+      const bot = getTelegramBot();
+      await bot.stop();
+      setIsEnabled(false);
+    } catch (err2) {
+      const errorMsg = err2 instanceof Error ? err2.message : "Failed to stop Telegram bot";
+      setError(errorMsg);
+      throw err2;
     }
-    output += "\n";
-  }
-  return output;
+  }, [isEnabled]);
+  const toggle = useCallback3(async () => {
+    if (isEnabled) {
+      await stop();
+    } else {
+      await start();
+    }
+  }, [isEnabled, start, stop]);
+  return {
+    isEnabled,
+    isStarting,
+    error,
+    lastMessage,
+    toggle,
+    start,
+    stop
+  };
 }
 
 // src/hooks/useTasks.ts
+import { useState as useState5, useCallback as useCallback4 } from "react";
 function useTasks(onProgress) {
   const [isRunning, setIsRunning] = useState5(false);
   const [currentTask, setCurrentTask] = useState5(null);