@projectservan8n/cnapse 0.5.8 → 0.6.1

package/dist/index.js

@@ -1250,6 +1250,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 +1285,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 +1439,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 +1502,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) {
@@ -1465,6 +1752,7 @@ var TelegramBotService = class extends EventEmitter {
   bot = null;
   isRunning = false;
   allowedChatIds = /* @__PURE__ */ new Set();
+  chatHistory = /* @__PURE__ */ new Map();
   constructor() {
     super();
   }
@@ -1622,13 +1910,58 @@ ${result.error}
       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: ctx.chat.id,
-        text: ctx.message.text,
-        from: ctx.from.username || ctx.from.first_name || "User"
+        chatId,
+        text: userText,
+        from
       };
       this.emit("message", message);
-      this.emit("command", "chat", ctx.message.text, ctx.chat.id);
+      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 ctx.reply(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 ctx.reply(chunk);
+          }
+        } else {
+          await ctx.reply(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);
@@ -1643,6 +1976,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
    */
@@ -2271,17 +2683,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]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectservan8n/cnapse",
-  "version": "0.5.8",
+  "version": "0.6.1",
   "description": "Autonomous PC intelligence - AI assistant for desktop automation",
   "type": "module",
   "main": "dist/index.js",

package/src/agents/computer.ts

@@ -16,7 +16,13 @@ Available tools:
 - getActiveWindow() - Get info about the currently focused window
 - listWindows() - List all open windows
 - focusWindow(title) - Focus a window by title (partial match)
+- minimizeWindow(title?) - Minimize a window by title, or active window if no title
+- maximizeWindow(title?) - Maximize a window by title, or active window if no title
+- closeWindow(title?) - Close a window by title, or active window if no title
+- restoreWindow(title) - Restore a minimized window by title
 - scrollMouse(amount) - Scroll mouse wheel (positive=up, negative=down)
+- dragMouse(startX, startY, endX, endY) - Drag mouse from one point to another
+- getMousePosition() - Get current mouse position
 
 Guidelines:
 1. Always confirm dangerous actions (like closing windows with unsaved work)
@@ -25,6 +31,13 @@ Guidelines:
 4. Report what you see/do at each step
 5. If something fails, try alternative approaches
 
+Window control examples:
+- minimizeWindow("Visual Studio Code") - Minimize VS Code
+- minimizeWindow() - Minimize the currently active window
+- maximizeWindow("Chrome") - Maximize Chrome
+- closeWindow("Notepad") - Close Notepad
+- restoreWindow("Discord") - Restore minimized Discord
+
 Common keyboard shortcuts:
 - Copy: control+c
 - Paste: control+v
@@ -52,6 +65,10 @@ When asked to open an application:
     'getActiveWindow',
     'listWindows',
     'focusWindow',
+    'minimizeWindow',
+    'maximizeWindow',
+    'closeWindow',
+    'restoreWindow',
     'scrollMouse',
     'dragMouse',
     'getMousePosition',

package/src/agents/executor.ts

@@ -114,6 +114,14 @@ export async function executeTool(call: ToolCall): Promise<ToolResult> {
         return await computer.listWindows();
       case 'focusWindow':
         return await computer.focusWindow(args.title as string);
+      case 'minimizeWindow':
+        return await computer.minimizeWindow(args.title as string | undefined);
+      case 'maximizeWindow':
+        return await computer.maximizeWindow(args.title as string | undefined);
+      case 'closeWindow':
+        return await computer.closeWindow(args.title as string | undefined);
+      case 'restoreWindow':
+        return await computer.restoreWindow(args.title as string);
       case 'scrollMouse':
         return await computer.scrollMouse(args.amount as number);
       case 'dragMouse':

package/src/components/App.tsx

@@ -202,6 +202,21 @@ export function App() {
     }
   }, [chat, tasks]);
 
+  // Check if message looks like a computer control request
+  const isComputerControlRequest = useCallback((text: string): boolean => {
+    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));
+  }, []);
+
   // Submit handler
   const handleSubmit = useCallback(async (value: string) => {
     if (!value.trim()) return;
@@ -209,12 +224,16 @@ export function App() {
 
     if (value.startsWith('/')) {
       await handleCommand(value);
+    } else if (isComputerControlRequest(value)) {
+      // Auto-route to task system for computer control
+      chat.addSystemMessage(`🤖 Executing: ${value}`);
+      await handleTaskCommand(value);
     } else {
       setStatus('Thinking...');
       await chat.sendMessage(value);
       setStatus('Ready');
     }
-  }, [chat, handleCommand]);
+  }, [chat, handleCommand, handleTaskCommand, isComputerControlRequest]);
 
   // Provider selection callback
   const handleProviderSelect = useCallback((provider: string, model: string) => {

package/src/services/telegram.ts

@@ -6,6 +6,8 @@ import { EventEmitter } from 'events';
 import { getConfig, getApiKey } from '../lib/config.js';
 import { describeScreen, captureScreenshot } from '../lib/vision.js';
 import { runCommand } from '../tools/shell.js';
+import { chat as chatWithAI, chatWithVision, Message } from '../lib/api.js';
+import * as computer from '../tools/computer.js';
 
 export interface TelegramMessage {
   chatId: number;
@@ -25,6 +27,7 @@ export class TelegramBotService extends EventEmitter {
   private bot: any = null;
   private isRunning = false;
   private allowedChatIds: Set<number> = new Set();
+  private chatHistory: Map<number, Message[]> = new Map();
 
   constructor() {
     super();
@@ -205,7 +208,7 @@ export class TelegramBotService extends EventEmitter {
       await ctx.reply(status);
     });
 
-    // Handle text messages - forward to AI
+    // Handle text messages - forward to AI and respond
     this.bot.on('text', async (ctx: any) => {
       if (!this.isAllowed(ctx.chat.id)) {
         return;
@@ -216,14 +219,79 @@ export class TelegramBotService extends EventEmitter {
         return;
       }
 
+      const chatId = ctx.chat.id;
+      const userText = ctx.message.text;
+      const from = ctx.from.username || ctx.from.first_name || 'User';
+
       const message: TelegramMessage = {
-        chatId: ctx.chat.id,
-        text: ctx.message.text,
-        from: ctx.from.username || ctx.from.first_name || 'User',
+        chatId,
+        text: userText,
+        from,
       };
 
       this.emit('message', message);
-      this.emit('command', 'chat', ctx.message.text, ctx.chat.id);
+
+      // Get or initialize chat history for this user
+      if (!this.chatHistory.has(chatId)) {
+        this.chatHistory.set(chatId, []);
+      }
+      const history = this.chatHistory.get(chatId)!;
+
+      // Add user message to history
+      history.push({ role: 'user', content: userText });
+
+      // Keep only last 10 messages for context
+      if (history.length > 10) {
+        history.splice(0, history.length - 10);
+      }
+
+      try {
+        // Send typing indicator
+        await ctx.sendChatAction('typing');
+
+        // Check if this looks like a computer control request
+        const computerControlResult = await this.tryComputerControl(userText);
+        if (computerControlResult) {
+          await ctx.reply(computerControlResult);
+          history.push({ role: 'assistant', content: computerControlResult });
+          return;
+        }
+
+        // Check if this looks like a screen/vision request
+        const isVisionRequest = /screen|see|look|what('?s| is) (on|visible)|show me|screenshot/i.test(userText);
+
+        let response;
+        if (isVisionRequest) {
+          // Capture screenshot and use vision
+          const screenshot = await captureScreenshot();
+          if (screenshot) {
+            response = await chatWithVision(history, screenshot);
+          } else {
+            response = await chatWithAI(history);
+          }
+        } else {
+          response = await chatWithAI(history);
+        }
+
+        // Add assistant response to history
+        history.push({ role: 'assistant', content: response.content });
+
+        // Send response (split if too long for Telegram)
+        const responseText = response.content || '(no response)';
+        if (responseText.length > 4000) {
+          // Split into chunks
+          const chunks = responseText.match(/.{1,4000}/gs) || [responseText];
+          for (const chunk of chunks) {
+            await ctx.reply(chunk);
+          }
+        } else {
+          await ctx.reply(responseText);
+        }
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+        await ctx.reply(`❌ Error: ${errorMsg}`);
+        this.emit('error', new Error(errorMsg));
+      }
     });
 
     // Error handling
@@ -243,6 +311,117 @@ export class TelegramBotService extends EventEmitter {
     return this.allowedChatIds.has(chatId);
   }
 
+  /**
+   * Try to execute computer control commands directly
+   * Returns response string if handled, null if not a computer command
+   */
+  private async tryComputerControl(text: string): Promise<string | null> {
+    const lower = text.toLowerCase();
+
+    // Minimize window
+    let match = lower.match(/minimize\s+(?:the\s+)?(.+)/i);
+    if (match) {
+      const result = await computer.minimizeWindow(match[1].trim());
+      return result.success ? `✅ ${result.output}` : `❌ ${result.error}`;
+    }
+
+    // Maximize window
+    match = lower.match(/maximize\s+(?:the\s+)?(.+)/i);
+    if (match) {
+      const result = await computer.maximizeWindow(match[1].trim());
+      return result.success ? `✅ ${result.output}` : `❌ ${result.error}`;
+    }
+
+    // Close window
+    match = lower.match(/close\s+(?:the\s+)?(.+)/i);
+    if (match) {
+      const result = await computer.closeWindow(match[1].trim());
+      return result.success ? `✅ ${result.output}` : `❌ ${result.error}`;
+    }
+
+    // Restore window
+    match = lower.match(/restore\s+(?:the\s+)?(.+)/i);
+    if (match) {
+      const result = await computer.restoreWindow(match[1].trim());
+      return result.success ? `✅ ${result.output}` : `❌ ${result.error}`;
+    }
+
+    // Focus/open window
+    match = lower.match(/(?:focus|open|switch to)\s+(?:the\s+)?(.+)/i);
+    if (match) {
+      const result = await computer.focusWindow(match[1].trim());
+      return result.success ? `✅ ${result.output}` : `❌ ${result.error}`;
+    }
+
+    // Type text
+    match = text.match(/type\s+["'](.+)["']/i);
+    if (match) {
+      const result = await computer.typeText(match[1]);
+      return result.success ? `✅ ${result.output}` : `❌ ${result.error}`;
+    }
+
+    // Press key
+    match = lower.match(/press\s+(?:the\s+)?(\w+)/i);
+    if (match) {
+      const result = await computer.pressKey(match[1]);
+      return result.success ? `✅ ${result.output}` : `❌ ${result.error}`;
+    }
+
+    // Click
+    if (/^click$/i.test(lower) || /click\s+(?:the\s+)?mouse/i.test(lower)) {
+      const result = await computer.clickMouse('left');
+      return result.success ? `✅ ${result.output}` : `❌ ${result.error}`;
+    }
+
+    // Right click
+    if (/right\s*click/i.test(lower)) {
+      const result = await computer.clickMouse('right');
+      return result.success ? `✅ ${result.output}` : `❌ ${result.error}`;
+    }
+
+    // Double click
+    if (/double\s*click/i.test(lower)) {
+      const result = await computer.doubleClick();
+      return result.success ? `✅ ${result.output}` : `❌ ${result.error}`;
+    }
+
+    // Move mouse to coordinates
+    match = lower.match(/move\s+(?:the\s+)?mouse\s+(?:to\s+)?(\d+)[,\s]+(\d+)/i);
+    if (match) {
+      const result = await computer.moveMouse(parseInt(match[1]), parseInt(match[2]));
+      return result.success ? `✅ ${result.output}` : `❌ ${result.error}`;
+    }
+
+    // Scroll
+    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 computer.scrollMouse(amount);
+      return result.success ? `✅ ${result.output}` : `❌ ${result.error}`;
+    }
+
+    // List windows
+    if (/list\s+(?:all\s+)?windows/i.test(lower) || /what\s+windows/i.test(lower)) {
+      const result = await computer.listWindows();
+      return result.success ? `📋 Open Windows:\n${result.output}` : `❌ ${result.error}`;
+    }
+
+    // Get active window
+    if (/(?:active|current|focused)\s+window/i.test(lower) || /what\s+(?:window|app)/i.test(lower)) {
+      const result = await computer.getActiveWindow();
+      return result.success ? `🪟 Active: ${result.output}` : `❌ ${result.error}`;
+    }
+
+    // Mouse position
+    if (/mouse\s+position/i.test(lower) || /where.*mouse/i.test(lower)) {
+      const result = await computer.getMousePosition();
+      return result.success ? `🖱️ ${result.output}` : `❌ ${result.error}`;
+    }
+
+    // Not a computer control command
+    return null;
+  }
+
   /**
    * Send a message to a specific chat
    */

package/src/tools/computer.ts

@@ -288,6 +288,188 @@ export async function focusWindow(title: string): Promise<ToolResult> {
   }
 }
 
+/**
+ * Minimize a window by title (or active window if no title)
+ */
+export async function minimizeWindow(title?: string): Promise<ToolResult> {
+  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 execAsync(`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 {
+        // Minimize active window using Alt+Space, N
+        await execAsync(`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 execAsync(`osascript -e 'tell application "${title}" to set miniaturized of window 1 to true'`);
+      } else {
+        await execAsync(`osascript -e 'tell application "System Events" to keystroke "m" using command down'`);
+      }
+      return ok(`Minimized window${title ? `: ${title}` : ''}`);
+    } else {
+      if (title) {
+        await execAsync(`wmctrl -r "${title}" -b add,hidden`);
+      } else {
+        await execAsync(`xdotool getactivewindow windowminimize`);
+      }
+      return ok(`Minimized window${title ? `: ${title}` : ''}`);
+    }
+  } catch (error) {
+    return err(`Failed to minimize window: ${error instanceof Error ? error.message : 'Unknown error'}`);
+  }
+}
+
+/**
+ * Maximize a window by title (or active window if no title)
+ */
+export async function maximizeWindow(title?: string): Promise<ToolResult> {
+  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 execAsync(`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 {
+        // Maximize active window using Alt+Space, X
+        await execAsync(`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 execAsync(`osascript -e 'tell application "${title}" to set zoomed of window 1 to true'`);
+      } else {
+        await execAsync(`osascript -e 'tell application "System Events" to keystroke "f" using {control down, command down}'`);
+      }
+      return ok(`Maximized window${title ? `: ${title}` : ''}`);
+    } else {
+      if (title) {
+        await execAsync(`wmctrl -r "${title}" -b add,maximized_vert,maximized_horz`);
+      } else {
+        await execAsync(`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'}`);
+  }
+}
+
+/**
+ * Close a window by title (or active window if no title)
+ */
+export async function closeWindow(title?: string): Promise<ToolResult> {
+  try {
+    if (process.platform === 'win32') {
+      if (title) {
+        const escaped = title.replace(/'/g, "''");
+        await execAsync(`powershell -Command "Get-Process | Where-Object { $_.MainWindowTitle -like '*${escaped}*' } | ForEach-Object { $_.CloseMainWindow() }"`, { shell: 'cmd.exe' });
+        return ok(`Closed window: ${title}`);
+      } else {
+        await execAsync(`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 execAsync(`osascript -e 'tell application "${title}" to close window 1'`);
+      } else {
+        await execAsync(`osascript -e 'tell application "System Events" to keystroke "w" using command down'`);
+      }
+      return ok(`Closed window${title ? `: ${title}` : ''}`);
+    } else {
+      if (title) {
+        await execAsync(`wmctrl -c "${title}"`);
+      } else {
+        await execAsync(`xdotool getactivewindow windowclose`);
+      }
+      return ok(`Closed window${title ? `: ${title}` : ''}`);
+    }
+  } catch (error) {
+    return err(`Failed to close window: ${error instanceof Error ? error.message : 'Unknown error'}`);
+  }
+}
+
+/**
+ * Restore a minimized window by title
+ */
+export async function restoreWindow(title: string): Promise<ToolResult> {
+  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 execAsync(`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 execAsync(`osascript -e 'tell application "${title}" to set miniaturized of window 1 to false'`);
+      return ok(`Restored window: ${title}`);
+    } else {
+      await execAsync(`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'}`);
+  }
+}
+
 /**
  * Scroll mouse wheel
  */
@@ -383,6 +565,10 @@ export function getComputerTools() {
     getActiveWindow,
     listWindows,
     focusWindow,
+    minimizeWindow,
+    maximizeWindow,
+    closeWindow,
+    restoreWindow,
     scrollMouse,
     dragMouse,
     getMousePosition,
@@ -436,6 +622,26 @@ export const computerTools = [
     description: 'Focus a window by title',
     parameters: { type: 'object', properties: { title: { type: 'string' } }, required: ['title'] },
   },
+  {
+    name: 'minimizeWindow',
+    description: 'Minimize a window by title (or active window if no title given)',
+    parameters: { type: 'object', properties: { title: { type: 'string', description: 'Window title to minimize (partial match). Leave empty for active window.' } } },
+  },
+  {
+    name: 'maximizeWindow',
+    description: 'Maximize a window by title (or active window if no title given)',
+    parameters: { type: 'object', properties: { title: { type: 'string', description: 'Window title to maximize (partial match). Leave empty for active window.' } } },
+  },
+  {
+    name: 'closeWindow',
+    description: 'Close a window by title (or active window if no title given)',
+    parameters: { type: 'object', properties: { title: { type: 'string', description: 'Window title to close (partial match). Leave empty for active window.' } } },
+  },
+  {
+    name: 'restoreWindow',
+    description: 'Restore a minimized window by title',
+    parameters: { type: 'object', properties: { title: { type: 'string', description: 'Window title to restore (partial match)' } }, required: ['title'] },
+  },
   {
     name: 'scrollMouse',
     description: 'Scroll mouse wheel (positive=up, negative=down)',