Add clipboard management capabilities with read functionality for multiple OS

Author: PrashamTrivedi

src/config/constants.ts

@@ -59,6 +59,9 @@ You have access to following tools and capabilities:
     - Arguments: none
     - Name: "clear_memories"
     - Arguments: none
+- CLIPBOARD_TOOLS:
+    - Name: "read_clipboard"
+    - Arguments: none
 
 Before taking any action, follow these steps:
 
@@ -101,7 +104,7 @@ export const API_CONFIG = {
     MAX_INTENT_TOKENS: 20,
 }
 
-export const MEMORY_TOOLS: Anthropic.Beta.BetaToolUnion[] = [
+export const MEMORY_TOOLS: Anthropic.Beta.BetaTool[] = [
     {
         name: "add_memory",
         description: "Add a new memory to the system",
@@ -136,3 +139,12 @@ export const MEMORY_TOOLS: Anthropic.Beta.BetaToolUnion[] = [
         },
     },
 ]
+export const CLIPBOARD_TOOLS: Anthropic.Beta.BetaTool[] = [
+    {
+        type: "custom",
+        name: "read_clipboard",
+        description: "Read content from system clipboard",
+        input_schema: {type: "object", properties: {}, required: []}
+
+    }
+]

src/modules/clipboard/clipboard.ts

@@ -0,0 +1,59 @@
+import {log} from "../../config/logging.ts"
+
+export class ClipboardManager {
+    private async readLinux(): Promise<string> {
+        try {
+            // Try xclip first
+            try {
+                const command = new Deno.Command("xclip", {
+                    args: ["-o", "-selection", "clipboard"],
+                })
+                const output = await command.output()
+                return new TextDecoder().decode(output.stdout).trim()
+            } catch {
+                // Fallback to xsel
+                const command = new Deno.Command("xsel", {
+                    args: ["--clipboard", "--output"],
+                })
+                const output = await command.output()
+                return new TextDecoder().decode(output.stdout).trim()
+            }
+        } catch (error) {
+            throw new Error("Clipboard access requires xclip or xsel to be installed")
+        }
+    }
+
+    private async readMac(): Promise<string> {
+        const command = new Deno.Command("pbpaste")
+        const output = await command.output()
+        return new TextDecoder().decode(output.stdout).trim()
+    }
+
+    private async readWindows(): Promise<string> {
+        const command = new Deno.Command("powershell.exe", {
+            args: ["-Command", "Get-Clipboard"],
+        })
+        const output = await command.output()
+        return new TextDecoder().decode(output.stdout).trim()
+    }
+
+    async readClipboard(): Promise<string> {
+        try {
+            const os = Deno.build.os
+            const isWsl = Deno.env.get("WSL_DISTRO_NAME") !== undefined
+
+            if (isWsl || os === "windows") {
+                return await this.readWindows()
+            } else if (os === "darwin") {
+                return await this.readMac()
+            } else if (os === "linux") {
+                return await this.readLinux()
+            } else {
+                throw new Error(`Unsupported platform: ${os}`)
+            }
+        } catch (error) {
+            log.error(`Error reading clipboard: ${error}`)
+            throw new Error(`Failed to read clipboard: ${error}`)
+        }
+    }
+}

src/modules/hybrid/hybrid_session.ts

@@ -1,14 +1,16 @@
-import { BaseSession } from "../../utils/session.ts";
-import { COMBINED_SYSTEM_PROMPT, API_CONFIG, MEMORY_TOOLS } from "../../config/constants.ts";
-import { log } from "../../config/logging.ts";
-import { ToolHandler } from "../../utils/tool_handler.ts";
+import {BaseSession} from "../../utils/session.ts"
+import {COMBINED_SYSTEM_PROMPT, API_CONFIG, MEMORY_TOOLS, CLIPBOARD_TOOLS} from "../../config/constants.ts"
+import {log} from "../../config/logging.ts"
+import {ToolHandler} from "../../utils/tool_handler.ts"
+
+
 
 export class HybridSession extends BaseSession {
-    private toolHandler: ToolHandler;
+    private toolHandler: ToolHandler
 
     constructor(sessionId: string, noAgi = false) {
-        super(sessionId);
-        this.toolHandler = new ToolHandler(noAgi);
+        super(sessionId)
+        this.toolHandler = new ToolHandler(noAgi)
     }
 
     async process(prompt: string): Promise<void> {
@@ -19,67 +21,68 @@ export class HybridSession extends BaseSession {
                 isWsl: Deno.env.get("WSL_DISTRO_NAME") !== undefined,
                 shell: Deno.env.get("SHELL") || "Unknown",
                 cwd: Deno.cwd(),
-            };
+            }
 
             const message = {
                 role: "user",
-                content: [{ type: "text", text: prompt }],
-            };
-            this.messages = [message];
+                content: [{type: "text", text: prompt}],
+            }
+            this.messages = [message]
 
-            log.info(`User input: ${JSON.stringify(message)}`);
+            log.info(`User input: ${JSON.stringify(message)}`)
 
             while (true) {
                 const response = await this.client.beta.messages.create({
                     model: API_CONFIG.MODEL,
                     max_tokens: API_CONFIG.MAX_TOKENS,
                     messages: this.messages,
                     tools: [
-                        { type: "bash_20241022", name: "bash" },
-                        { type: "text_editor_20241022", name: "str_replace_editor" },
+                        {type: "bash_20241022", name: "bash"},
+                        {type: "text_editor_20241022", name: "str_replace_editor"},
                         ...MEMORY_TOOLS,
+                        ...CLIPBOARD_TOOLS,
                     ],
                     system: `${COMBINED_SYSTEM_PROMPT}\nSystem Context: ${JSON.stringify(systemInfo)}`,
                     betas: ["computer-use-2024-10-22"],
-                });
+                })
 
-                const inputTokens = response.usage?.input_tokens ?? 0;
-                const outputTokens = response.usage?.output_tokens ?? 0;
-                this.logger.updateTokenUsage(inputTokens, outputTokens);
+                const inputTokens = response.usage?.input_tokens ?? 0
+                const outputTokens = response.usage?.output_tokens ?? 0
+                this.logger.updateTokenUsage(inputTokens, outputTokens)
 
                 const responseContent = response.content.map((block) =>
-                    block.type === "text" ? { type: "text", text: block.text } : block
-                );
+                    block.type === "text" ? {type: "text", text: block.text} : block
+                )
 
-                this.messages.push({ role: "assistant", content: responseContent });
+                this.messages.push({role: "assistant", content: responseContent})
 
                 if (response.stop_reason !== "tool_use") {
-                    console.log(response.content.find((block) => block.type === "text")?.text ?? "");
-                    break;
+                    console.log(response.content.find((block) => block.type === "text")?.text ?? "")
+                    break
                 }
 
-                const toolResults = await this.toolHandler.processToolCalls(response.content);
+                const toolResults = await this.toolHandler.processToolCalls(response.content)
 
                 if (toolResults?.length) {
                     this.messages.push({
                         role: "user",
                         content: [toolResults[0].output],
-                    });
+                    })
 
                     if (toolResults[0].output.is_error) {
-                        log.error(`Error: ${toolResults[0].output.content[0].text}`);
-                        break;
+                        log.error(`Error: ${toolResults[0].output.content[0].text}`)
+                        break
                     }
                 }
             }
 
-            this.logger.logTotalCost();
+            this.logger.logTotalCost()
         } catch (error) {
-            log.error(`Error in hybrid process: ${error instanceof Error ? error.message : String(error)}`);
+            log.error(`Error in hybrid process: ${error instanceof Error ? error.message : String(error)}`)
             if (error instanceof Error && error.stack) {
-                log.error(error.stack);
+                log.error(error.stack)
             }
-            throw error;
+            throw error
         }
     }
 }

src/utils/tool_handler.ts

@@ -1,34 +1,37 @@
-import { BashHandlers } from "../modules/bash/handlers.ts";
-import { EditorHandlers } from "../modules/editor/handlers.ts";
-import { MemoryManager } from "../modules/memory/memory_manager.ts";
-import { ToolResult } from "../types/interfaces.ts";
-import { log } from "../config/logging.ts";
+import {BashHandlers} from "../modules/bash/handlers.ts"
+import {EditorHandlers} from "../modules/editor/handlers.ts"
+import {MemoryManager} from "../modules/memory/memory_manager.ts"
+import {ToolResult} from "../types/interfaces.ts"
+import {log} from "../config/logging.ts"
+import {ClipboardManager} from "../modules/clipboard/clipboard.ts"
 
 export class ToolHandler {
-    private bashHandlers: BashHandlers;
-    private editorHandlers: EditorHandlers;
-    private memoryManager: MemoryManager;
+    private bashHandlers: BashHandlers
+    private editorHandlers: EditorHandlers
+    private memoryManager: MemoryManager
+    private clipboardManager: ClipboardManager
 
     constructor(noAgi = false) {
-        this.bashHandlers = new BashHandlers(noAgi);
-        this.editorHandlers = new EditorHandlers();
-        this.memoryManager = new MemoryManager();
+        this.bashHandlers = new BashHandlers(noAgi)
+        this.editorHandlers = new EditorHandlers()
+        this.memoryManager = new MemoryManager()
+        this.clipboardManager = new ClipboardManager()
     }
 
     async processToolCalls(content: any[]): Promise<ToolResult[]> {
-        const results: ToolResult[] = [];
+        const results: ToolResult[] = []
 
         for (const toolCall of content) {
             if (toolCall.type === "tool_use") {
-                let result;
-                let isError = false;
+                let result
+                let isError = false
 
                 try {
-                    result = await this.handleTool(toolCall);
-                    isError = "error" in result;
+                    result = await this.handleTool(toolCall)
+                    isError = typeof result === 'object' && result !== null && 'error' in result
                 } catch (error) {
-                    result = { error: String(error) };
-                    isError = true;
+                    result = {error: String(error)}
+                    isError = true
                 }
 
                 results.push({
@@ -42,28 +45,30 @@ export class ToolHandler {
                         tool_use_id: toolCall.id,
                         is_error: isError,
                     },
-                });
+                })
             }
         }
 
-        return results;
+        return results
     }
 
     private async handleTool(toolCall: any) {
         switch (toolCall.name) {
             case "bash":
-                return await this.bashHandlers.handleBashCommand(toolCall.input);
+                return await this.bashHandlers.handleBashCommand(toolCall.input)
             case "str_replace_editor":
-                return await this.editorHandlers.handleTextEditorTool(toolCall.input);
+                return await this.editorHandlers.handleTextEditorTool(toolCall.input)
             case "add_memory":
-                return await this.memoryManager.addMemory(toolCall.input.content);
+                return await this.memoryManager.addMemory(toolCall.input.content)
             case "get_memories":
-                return await this.memoryManager.getMemories();
+                return await this.memoryManager.getMemories()
             case "clear_memories":
-                await this.memoryManager.clearMemories();
-                return { message: "Memories cleared successfully" };
+                await this.memoryManager.clearMemories()
+                return {message: "Memories cleared successfully"}
+            case "read_clipboard":
+                return await this.clipboardManager.readClipboard()
             default:
-                throw new Error(`Unknown tool: ${toolCall.name}`);
+                throw new Error(`Unknown tool: ${toolCall.name}`)
         }
     }
 }