@projectservan8n/cnapse 0.6.0 → 0.6.2

package/dist/index.js

@@ -925,10 +925,10 @@ async function captureScreenFallback() {
   const { exec: exec6 } = await import("child_process");
   const { promisify: promisify6 } = await import("util");
   const { tmpdir } = await import("os");
-  const { join: join2 } = await import("path");
-  const { readFile, unlink } = await import("fs/promises");
+  const { join: join3 } = await import("path");
+  const { readFile: readFile2, unlink } = await import("fs/promises");
   const execAsync6 = promisify6(exec6);
-  const tempFile = join2(tmpdir(), `cnapse-screen-${Date.now()}.png`);
+  const tempFile = join3(tmpdir(), `cnapse-screen-${Date.now()}.png`);
   try {
     const platform = process.platform;
     if (platform === "win32") {
@@ -947,7 +947,7 @@ async function captureScreenFallback() {
     } else {
       await execAsync6(`gnome-screenshot -f "${tempFile}" 2>/dev/null || scrot "${tempFile}" 2>/dev/null || import -window root "${tempFile}"`);
     }
-    const imageBuffer = await readFile(tempFile);
+    const imageBuffer = await readFile2(tempFile);
     await unlink(tempFile).catch(() => {
     });
     return imageBuffer.toString("base64");
@@ -1238,6 +1238,56 @@ import { EventEmitter } from "events";
 import { exec as exec5 } from "child_process";
 import { promisify as promisify5 } 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";
 
@@ -1250,6 +1300,20 @@ var execAsync3 = promisify3(exec3);
 import { exec as exec4 } from "child_process";
 import { promisify as promisify4 } from "util";
 var execAsync4 = promisify4(exec4);
+async function moveMouse(x, y) {
+  try {
+    if (process.platform === "win32") {
+      await execAsync4(`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 execAsync4(`cliclick m:${x},${y}`);
+    } else {
+      await execAsync4(`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") {
@@ -1271,6 +1335,28 @@ ${button === "left" ? "[Win32.Mouse]::mouse_event(0x02, 0, 0, 0, 0); [Win32.Mous
     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 execAsync4(`powershell -Command "${script.replace(/\n/g, " ")}"`, { shell: "cmd.exe" });
+    } else if (process.platform === "darwin") {
+      await execAsync4(`cliclick dc:.`);
+    } else {
+      await execAsync4(`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") {
@@ -1403,6 +1489,54 @@ async function keyCombo(keys) {
     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 execAsync4(`powershell -Command "${script.replace(/\n/g, " ")}"`, { shell: "cmd.exe" });
+      return ok(stdout.trim() || "Unknown window");
+    } else if (process.platform === "darwin") {
+      const { stdout } = await execAsync4(`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 execAsync4(`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 execAsync4(`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 execAsync4(`osascript -e 'tell application "System Events" to get name of every application process whose visible is true'`);
+      return ok(stdout);
+    } else {
+      const { stdout } = await execAsync4(`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") {
@@ -1418,6 +1552,209 @@ async function focusWindow(title) {
     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 execAsync4(`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 execAsync4(`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 execAsync4(`osascript -e 'tell application "${title}" to set miniaturized of window 1 to true'`);
+      } else {
+        await execAsync4(`osascript -e 'tell application "System Events" to keystroke "m" using command down'`);
+      }
+      return ok(`Minimized window${title ? `: ${title}` : ""}`);
+    } else {
+      if (title) {
+        await execAsync4(`wmctrl -r "${title}" -b add,hidden`);
+      } else {
+        await execAsync4(`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 execAsync4(`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 execAsync4(`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 execAsync4(`osascript -e 'tell application "${title}" to set zoomed of window 1 to true'`);
+      } else {
+        await execAsync4(`osascript -e 'tell application "System Events" to keystroke "f" using {control down, command down}'`);
+      }
+      return ok(`Maximized window${title ? `: ${title}` : ""}`);
+    } else {
+      if (title) {
+        await execAsync4(`wmctrl -r "${title}" -b add,maximized_vert,maximized_horz`);
+      } else {
+        await execAsync4(`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 execAsync4(`powershell -Command "Get-Process | Where-Object { $_.MainWindowTitle -like '*${escaped}*' } | ForEach-Object { $_.CloseMainWindow() }"`, { shell: "cmd.exe" });
+        return ok(`Closed window: ${title}`);
+      } else {
+        await execAsync4(`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 execAsync4(`osascript -e 'tell application "${title}" to close window 1'`);
+      } else {
+        await execAsync4(`osascript -e 'tell application "System Events" to keystroke "w" using command down'`);
+      }
+      return ok(`Closed window${title ? `: ${title}` : ""}`);
+    } else {
+      if (title) {
+        await execAsync4(`wmctrl -c "${title}"`);
+      } else {
+        await execAsync4(`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 execAsync4(`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 execAsync4(`osascript -e 'tell application "${title}" to set miniaturized of window 1 to false'`);
+      return ok(`Restored window: ${title}`);
+    } else {
+      await execAsync4(`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 execAsync4(`powershell -Command "${script.replace(/\n/g, " ")}"`, { shell: "cmd.exe" });
+    } else if (process.platform === "darwin") {
+      const dir = amount > 0 ? "u" : "d";
+      await execAsync4(`cliclick -r ${dir}:${Math.abs(amount)}`);
+    } else {
+      const btn = amount > 0 ? "4" : "5";
+      await execAsync4(`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 execAsync4(`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 execAsync4(`cliclick p`);
+      return ok(`Mouse position: ${stdout.trim()}`);
+    } else {
+      const { stdout } = await execAsync4(`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) {
@@ -1461,6 +1798,65 @@ ${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);
+    }
+    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;
@@ -1642,6 +2038,12 @@ ${result.error}
       }
       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) {
@@ -1659,10 +2061,10 @@ ${result.error}
         if (responseText.length > 4e3) {
           const chunks = responseText.match(/.{1,4000}/gs) || [responseText];
           for (const chunk of chunks) {
-            await ctx.reply(chunk);
+            await sendFormattedMessage(ctx, chunk);
           }
         } else {
-          await ctx.reply(responseText);
+          await sendFormattedMessage(ctx, responseText);
         }
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : "Unknown error";
@@ -1683,6 +2085,85 @@ ${result.error}
     }
     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
    */
@@ -1778,14 +2259,14 @@ function useTelegram(onMessage) {
 import { useState as useState6, useCallback as useCallback4 } from "react";
 
 // src/lib/tasks.ts
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as path from "path";
 import * as os2 from "os";
 var TASK_MEMORY_FILE = path.join(os2.homedir(), ".cnapse", "task-memory.json");
 function loadTaskMemory() {
   try {
-    if (fs.existsSync(TASK_MEMORY_FILE)) {
-      const data = fs.readFileSync(TASK_MEMORY_FILE, "utf-8");
+    if (fs2.existsSync(TASK_MEMORY_FILE)) {
+      const data = fs2.readFileSync(TASK_MEMORY_FILE, "utf-8");
       return JSON.parse(data);
     }
   } catch {
@@ -1812,10 +2293,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 (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
     }
-    fs.writeFileSync(TASK_MEMORY_FILE, JSON.stringify(memory, null, 2));
+    fs2.writeFileSync(TASK_MEMORY_FILE, JSON.stringify(memory, null, 2));
   } catch {
   }
 }
@@ -1875,14 +2356,36 @@ Before outputting steps, THINK through these questions:
    - Typing too fast -> add small waits
 
 ## AVAILABLE ACTIONS
+
+### App Control
 - open_app: Open app via Run dialog (e.g., "open_app:notepad", "open_app:code", "open_app:chrome")
+- open_folder: Open VS Code with folder (e.g., "open_folder:E:/MyProject")
+- focus_window: Focus by title (e.g., "focus_window:Notepad")
+
+### Input
 - type_text: Type text string (e.g., "type_text:Hello World")
 - press_key: Single key (e.g., "press_key:enter", "press_key:escape", "press_key:tab")
 - key_combo: Key combination (e.g., "key_combo:control+s", "key_combo:alt+f4", "key_combo:meta+r")
 - click: Mouse click (e.g., "click:left", "click:right")
+
+### File Operations
+- read_file: Read file contents (e.g., "read_file:E:/test/index.html")
+- write_file: Write content to file (e.g., "write_file:E:/test/output.txt|Hello World")
+- list_files: List files in directory (e.g., "list_files:E:/test")
+
+### AI Coding
+- generate_code: AI generates code based on description (e.g., "generate_code:E:/test/index.html|create an HTML page with input on left, output on right")
+- edit_code: AI modifies existing code (e.g., "edit_code:E:/test/app.js|add error handling to the fetch calls")
+
+### Web Browsing
+- open_url: Open URL in default browser (e.g., "open_url:https://perplexity.ai")
+- browse_and_ask: Open AI website, type question, wait for response (e.g., "browse_and_ask:perplexity|What is the capital of France?")
+- browse_and_ask: Supports: perplexity, chatgpt, claude, google
+
+### Utility
 - wait: Wait N seconds (e.g., "wait:2" - use 1-3s for app loads)
-- focus_window: Focus by title (e.g., "focus_window:Notepad")
 - screenshot: Capture and describe screen
+- shell: Run shell command (e.g., "shell:npm install")
 ${learnedExamples}
 ## EXAMPLES WITH REASONING
 
@@ -1925,6 +2428,59 @@ Output:
   { "description": "Close active window with Alt+F4", "action": "key_combo:alt+f4" }
 ]
 
+### Example 4: "open folder E:/Test in vscode and create an HTML editor"
+Thinking:
+- Goal: Open VS Code with folder, then create/edit HTML file to be an editor
+- How: Use open_folder to launch VS Code with the folder, then use AI to generate code
+- Sequence: Open folder -> List files to see what exists -> Generate/edit the HTML
+- Edge case: File might not exist yet
+
+Output:
+[
+  { "description": "Open VS Code with the Test folder", "action": "open_folder:E:/Test" },
+  { "description": "Wait for VS Code to load", "action": "wait:3" },
+  { "description": "List files in the folder", "action": "list_files:E:/Test" },
+  { "description": "Generate HTML editor code", "action": "generate_code:E:/Test/editor.html|Create an HTML page with a code editor layout: textarea input on the left side, live preview output on the right side. Include basic CSS for split layout and JavaScript to update preview on input." }
+]
+
+### Example 5: "read the config.json and add a new setting"
+Thinking:
+- Goal: Read existing file, understand it, modify it
+- How: read_file to get contents, then edit_code to modify
+- Sequence: Read first, then edit
+
+Output:
+[
+  { "description": "Read the config file", "action": "read_file:config.json" },
+  { "description": "Add new setting to config", "action": "edit_code:config.json|add a new setting called 'darkMode' with value true" }
+]
+
+### Example 6: "ask perplexity what is the best programming language"
+Thinking:
+- Goal: Open Perplexity AI in browser and ask a question
+- How: Use browse_and_ask with perplexity target
+- Sequence: Open site -> type question -> wait for response -> screenshot result
+
+Output:
+[
+  { "description": "Ask Perplexity the question", "action": "browse_and_ask:perplexity|what is the best programming language" },
+  { "description": "Wait for response to generate", "action": "wait:5" },
+  { "description": "Capture the response", "action": "screenshot" }
+]
+
+### Example 7: "search google for weather today"
+Thinking:
+- Goal: Open Google and search for something
+- How: Use browse_and_ask with google target
+- Sequence: Open Google, search, capture results
+
+Output:
+[
+  { "description": "Search Google", "action": "browse_and_ask:google|weather today" },
+  { "description": "Wait for results", "action": "wait:2" },
+  { "description": "Capture search results", "action": "screenshot" }
+]
+
 ## YOUR TASK
 Now parse this request: "${input}"
 
@@ -2014,6 +2570,128 @@ async function executeStep(step) {
       await focusWindow(params);
       step.result = `Focused window: ${params}`;
       break;
+    case "open_folder":
+      await runCommand(`code "${params}"`, 1e4);
+      step.result = `Opened VS Code with folder: ${params}`;
+      break;
+    case "read_file": {
+      const readResult = await readFile(params);
+      if (readResult.success) {
+        step.result = readResult.output;
+      } else {
+        throw new Error(readResult.error || "Failed to read file");
+      }
+      break;
+    }
+    case "write_file": {
+      const [filePath, ...contentParts] = params.split("|");
+      const content = contentParts.join("|");
+      const writeResult = await writeFile(filePath, content);
+      if (writeResult.success) {
+        step.result = `Written to ${filePath}`;
+      } else {
+        throw new Error(writeResult.error || "Failed to write file");
+      }
+      break;
+    }
+    case "list_files": {
+      const listResult = await listDir(params, false);
+      if (listResult.success) {
+        step.result = listResult.output;
+      } else {
+        throw new Error(listResult.error || "Failed to list files");
+      }
+      break;
+    }
+    case "generate_code": {
+      const [codePath, ...descParts] = params.split("|");
+      const codeDescription = descParts.join("|");
+      const codePrompt = `Generate complete, working code for this request. Output ONLY the code, no explanations or markdown:
+
+Request: ${codeDescription}
+
+File: ${codePath}`;
+      const codeResponse = await chat([{ role: "user", content: codePrompt }]);
+      let generatedCode = codeResponse.content;
+      generatedCode = generatedCode.replace(/^```[\w]*\n?/gm, "").replace(/\n?```$/gm, "").trim();
+      const genResult = await writeFile(codePath, generatedCode);
+      if (genResult.success) {
+        step.result = `Generated and saved code to ${codePath}`;
+      } else {
+        throw new Error(genResult.error || "Failed to write generated code");
+      }
+      break;
+    }
+    case "edit_code": {
+      const [editPath, ...instrParts] = params.split("|");
+      const instructions = instrParts.join("|");
+      const existingResult = await readFile(editPath);
+      if (!existingResult.success) {
+        throw new Error(`Cannot read file: ${existingResult.error}`);
+      }
+      const editPrompt = `Edit this code according to the instructions. Output ONLY the complete modified code, no explanations or markdown:
+
+Instructions: ${instructions}
+
+Current code:
+${existingResult.output}`;
+      const editResponse = await chat([{ role: "user", content: editPrompt }]);
+      let editedCode = editResponse.content;
+      editedCode = editedCode.replace(/^```[\w]*\n?/gm, "").replace(/\n?```$/gm, "").trim();
+      const editWriteResult = await writeFile(editPath, editedCode);
+      if (editWriteResult.success) {
+        step.result = `Edited and saved ${editPath}`;
+      } else {
+        throw new Error(editWriteResult.error || "Failed to write edited code");
+      }
+      break;
+    }
+    case "shell": {
+      const shellResult = await runCommand(params, 3e4);
+      if (shellResult.success) {
+        step.result = shellResult.output || "Command completed";
+      } else {
+        throw new Error(shellResult.error || "Command failed");
+      }
+      break;
+    }
+    case "open_url": {
+      const url = params.startsWith("http") ? params : `https://${params}`;
+      if (process.platform === "win32") {
+        await runCommand(`start "" "${url}"`, 5e3);
+      } else if (process.platform === "darwin") {
+        await runCommand(`open "${url}"`, 5e3);
+      } else {
+        await runCommand(`xdg-open "${url}"`, 5e3);
+      }
+      step.result = `Opened ${url} in browser`;
+      break;
+    }
+    case "browse_and_ask": {
+      const [site, ...questionParts] = params.split("|");
+      const question = questionParts.join("|");
+      const sites = {
+        perplexity: { url: "https://www.perplexity.ai", waitTime: 3 },
+        chatgpt: { url: "https://chat.openai.com", waitTime: 4 },
+        claude: { url: "https://claude.ai", waitTime: 4 },
+        google: { url: "https://www.google.com", waitTime: 2 },
+        bing: { url: "https://www.bing.com", waitTime: 2 }
+      };
+      const siteConfig = sites[site.toLowerCase()] || { url: `https://${site}`, waitTime: 3 };
+      if (process.platform === "win32") {
+        await runCommand(`start "" "${siteConfig.url}"`, 5e3);
+      } else if (process.platform === "darwin") {
+        await runCommand(`open "${siteConfig.url}"`, 5e3);
+      } else {
+        await runCommand(`xdg-open "${siteConfig.url}"`, 5e3);
+      }
+      await sleep(siteConfig.waitTime * 1e3);
+      await typeText(question);
+      await sleep(300);
+      await pressKey("Return");
+      step.result = `Asked ${site}: "${question}"`;
+      break;
+    }
     case "screenshot":
       const vision = await describeScreen();
       step.result = vision.description;
@@ -2070,8 +2748,8 @@ function getTaskMemoryStats() {
 }
 function clearTaskMemory() {
   try {
-    if (fs.existsSync(TASK_MEMORY_FILE)) {
-      fs.unlinkSync(TASK_MEMORY_FILE);
+    if (fs2.existsSync(TASK_MEMORY_FILE)) {
+      fs2.unlinkSync(TASK_MEMORY_FILE);
     }
   } catch {
   }
@@ -2311,17 +2989,33 @@ ${tasks.format(task)}`);
       setStatus("Ready");
     }
   }, [chat2, tasks]);
+  const isComputerControlRequest = useCallback5((text) => {
+    const lower = text.toLowerCase();
+    const patterns = [
+      /^(can you |please |)?(open|close|minimize|maximize|restore|focus|click|type|press|scroll|move|drag)/i,
+      /^(can you |please |)?move (the |my |)mouse/i,
+      /^(can you |please |)?(start|launch|run) [a-z]/i,
+      /(open|close|minimize|maximize) (the |my |)?[a-z]/i,
+      /click (on |the |)/i,
+      /type ["'].+["']/i,
+      /press (enter|escape|tab|ctrl|alt|shift|space|backspace|delete|f\d+)/i
+    ];
+    return patterns.some((p) => p.test(lower));
+  }, []);
   const handleSubmit = useCallback5(async (value) => {
     if (!value.trim()) return;
     setInputValue("");
     if (value.startsWith("/")) {
       await handleCommand(value);
+    } else if (isComputerControlRequest(value)) {
+      chat2.addSystemMessage(`\u{1F916} Executing: ${value}`);
+      await handleTaskCommand(value);
     } else {
       setStatus("Thinking...");
       await chat2.sendMessage(value);
       setStatus("Ready");
     }
-  }, [chat2, handleCommand]);
+  }, [chat2, handleCommand, handleTaskCommand, isComputerControlRequest]);
   const handleProviderSelect = useCallback5((provider, model) => {
     chat2.addSystemMessage(`\u2705 Updated: ${provider} / ${model}`);
   }, [chat2]);