@projectservan8n/cnapse 0.5.8 → 0.6.0

package/dist/index.js

@@ -1465,6 +1465,7 @@ var TelegramBotService = class extends EventEmitter {
   bot = null;
   isRunning = false;
   allowedChatIds = /* @__PURE__ */ new Set();
+  chatHistory = /* @__PURE__ */ new Map();
   constructor() {
     super();
   }
@@ -1622,13 +1623,52 @@ ${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 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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectservan8n/cnapse",
-  "version": "0.5.8",
+  "version": "0.6.0",
   "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/services/telegram.ts

@@ -6,6 +6,7 @@ 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';
 
 export interface TelegramMessage {
   chatId: number;
@@ -25,6 +26,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 +207,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 +218,71 @@ 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 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

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)',