cowork-os 0.3.21

package/dist/electron/electron/agent/tools/system-tools.js

@@ -0,0 +1,578 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemTools = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
+const electron_1 = require("electron");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const DEFAULT_TIMEOUT = 30 * 1000; // 30 seconds
+/**
+ * SystemTools provides system-level capabilities beyond the workspace
+ * These tools enable more autonomous operation for general task completion
+ */
+class SystemTools {
+    constructor(workspace, daemon, taskId) {
+        this.workspace = workspace;
+        this.daemon = daemon;
+        this.taskId = taskId;
+    }
+    /**
+     * Update the workspace for this tool
+     */
+    setWorkspace(workspace) {
+        this.workspace = workspace;
+    }
+    /**
+     * Get system information (OS, CPU, memory, etc.)
+     */
+    async getSystemInfo() {
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'system_info',
+        });
+        const totalMemGB = (os.totalmem() / (1024 * 1024 * 1024)).toFixed(2);
+        const freeMemGB = (os.freemem() / (1024 * 1024 * 1024)).toFixed(2);
+        const uptimeHours = (os.uptime() / 3600).toFixed(1);
+        const result = {
+            platform: os.platform(),
+            arch: os.arch(),
+            osVersion: os.release(),
+            hostname: os.hostname(),
+            cpus: os.cpus().length,
+            totalMemory: `${totalMemGB} GB`,
+            freeMemory: `${freeMemGB} GB`,
+            uptime: `${uptimeHours} hours`,
+            homeDir: os.homedir(),
+            tempDir: os.tmpdir(),
+            shell: process.env.SHELL || 'unknown',
+            username: os.userInfo().username,
+        };
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'system_info',
+            success: true,
+        });
+        return result;
+    }
+    /**
+     * Read from system clipboard
+     */
+    async readClipboard() {
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'read_clipboard',
+        });
+        const text = electron_1.clipboard.readText();
+        const image = electron_1.clipboard.readImage();
+        const formats = electron_1.clipboard.availableFormats();
+        const result = {
+            text: text || '(no text in clipboard)',
+            hasImage: !image.isEmpty(),
+            formats,
+        };
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'read_clipboard',
+            success: true,
+            hasText: !!text,
+            hasImage: result.hasImage,
+        });
+        return result;
+    }
+    /**
+     * Write text to system clipboard
+     */
+    async writeClipboard(text) {
+        if (!text || typeof text !== 'string') {
+            throw new Error('Invalid text: must be a non-empty string');
+        }
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'write_clipboard',
+            textLength: text.length,
+        });
+        electron_1.clipboard.writeText(text);
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'write_clipboard',
+            success: true,
+        });
+        return { success: true };
+    }
+    /**
+     * Take a screenshot and save it to the workspace
+     * Uses Electron's desktopCapturer API
+     */
+    async takeScreenshot(options) {
+        const filename = options?.filename || `screenshot-${Date.now()}.png`;
+        const outputPath = path.join(this.workspace.path, filename);
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'take_screenshot',
+            filename,
+        });
+        try {
+            // Get all available sources (screens and windows)
+            const sources = await electron_1.desktopCapturer.getSources({
+                types: ['screen'],
+                thumbnailSize: { width: 1920, height: 1080 },
+            });
+            if (sources.length === 0) {
+                throw new Error('No screen sources available for capture');
+            }
+            // Use the primary screen
+            const primaryScreen = sources[0];
+            const image = primaryScreen.thumbnail;
+            if (image.isEmpty()) {
+                throw new Error('Failed to capture screenshot - image is empty');
+            }
+            // Save to file
+            const pngData = image.toPNG();
+            await fs.writeFile(outputPath, pngData);
+            const size = image.getSize();
+            this.daemon.logEvent(this.taskId, 'tool_result', {
+                tool: 'take_screenshot',
+                success: true,
+                path: filename,
+                width: size.width,
+                height: size.height,
+            });
+            return {
+                success: true,
+                path: filename,
+                width: size.width,
+                height: size.height,
+            };
+        }
+        catch (error) {
+            this.daemon.logEvent(this.taskId, 'tool_error', {
+                tool: 'take_screenshot',
+                error: error.message,
+            });
+            throw new Error(`Failed to take screenshot: ${error.message}`);
+        }
+    }
+    /**
+     * Open an application by name (macOS/Windows/Linux)
+     */
+    async openApplication(appName) {
+        if (!appName || typeof appName !== 'string') {
+            throw new Error('Invalid appName: must be a non-empty string');
+        }
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'open_application',
+            appName,
+        });
+        const platform = os.platform();
+        try {
+            let command;
+            if (platform === 'darwin') {
+                // macOS: Use 'open -a' command
+                command = `open -a "${appName}"`;
+            }
+            else if (platform === 'win32') {
+                // Windows: Use 'start' command
+                command = `start "" "${appName}"`;
+            }
+            else {
+                // Linux: Try common launchers
+                command = appName.toLowerCase();
+            }
+            await execAsync(command, { timeout: DEFAULT_TIMEOUT });
+            this.daemon.logEvent(this.taskId, 'tool_result', {
+                tool: 'open_application',
+                success: true,
+                appName,
+            });
+            return {
+                success: true,
+                message: `Opened ${appName}`,
+            };
+        }
+        catch (error) {
+            this.daemon.logEvent(this.taskId, 'tool_error', {
+                tool: 'open_application',
+                error: error.message,
+            });
+            throw new Error(`Failed to open application "${appName}": ${error.message}`);
+        }
+    }
+    /**
+     * Open a URL in the default browser
+     */
+    async openUrl(url) {
+        if (!url || typeof url !== 'string') {
+            throw new Error('Invalid URL: must be a non-empty string');
+        }
+        // Basic URL validation
+        try {
+            new URL(url);
+        }
+        catch {
+            throw new Error('Invalid URL format');
+        }
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'open_url',
+            url,
+        });
+        await electron_1.shell.openExternal(url);
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'open_url',
+            success: true,
+        });
+        return { success: true };
+    }
+    /**
+     * Open a file or folder in the system's default application
+     */
+    async openPath(filePath) {
+        if (!filePath || typeof filePath !== 'string') {
+            throw new Error('Invalid path: must be a non-empty string');
+        }
+        // Resolve relative to workspace
+        const fullPath = path.isAbsolute(filePath)
+            ? filePath
+            : path.resolve(this.workspace.path, filePath);
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'open_path',
+            path: filePath,
+        });
+        const result = await electron_1.shell.openPath(fullPath);
+        if (result) {
+            this.daemon.logEvent(this.taskId, 'tool_error', {
+                tool: 'open_path',
+                error: result,
+            });
+            return { success: false, error: result };
+        }
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'open_path',
+            success: true,
+        });
+        return { success: true };
+    }
+    /**
+     * Show a file in the system file manager (Finder/Explorer)
+     */
+    async showInFolder(filePath) {
+        if (!filePath || typeof filePath !== 'string') {
+            throw new Error('Invalid path: must be a non-empty string');
+        }
+        const fullPath = path.isAbsolute(filePath)
+            ? filePath
+            : path.resolve(this.workspace.path, filePath);
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'show_in_folder',
+            path: filePath,
+        });
+        electron_1.shell.showItemInFolder(fullPath);
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'show_in_folder',
+            success: true,
+        });
+        return { success: true };
+    }
+    /**
+     * Get environment variable value
+     */
+    async getEnvVariable(name) {
+        if (!name || typeof name !== 'string') {
+            throw new Error('Invalid variable name: must be a non-empty string');
+        }
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'get_env',
+            variable: name,
+        });
+        const value = process.env[name];
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'get_env',
+            exists: value !== undefined,
+        });
+        return {
+            value: value ?? null,
+            exists: value !== undefined,
+        };
+    }
+    /**
+     * Get the application's data directory
+     */
+    getAppPaths() {
+        return {
+            userData: electron_1.app.getPath('userData'),
+            temp: electron_1.app.getPath('temp'),
+            home: electron_1.app.getPath('home'),
+            downloads: electron_1.app.getPath('downloads'),
+            documents: electron_1.app.getPath('documents'),
+            desktop: electron_1.app.getPath('desktop'),
+        };
+    }
+    /**
+     * Execute AppleScript code on macOS
+     * This enables powerful automation capabilities for controlling applications and system features
+     */
+    async runAppleScript(script) {
+        if (!script || typeof script !== 'string') {
+            throw new Error('Invalid script: must be a non-empty string');
+        }
+        // Only available on macOS
+        if (os.platform() !== 'darwin') {
+            throw new Error('AppleScript is only available on macOS');
+        }
+        const { script: normalizedScript, modified } = this.normalizeAppleScript(script);
+        const approved = await this.daemon.requestApproval(this.taskId, 'run_applescript', 'Run AppleScript', {
+            script: normalizedScript,
+            scriptLength: normalizedScript.length,
+            normalized: modified,
+        });
+        if (!approved) {
+            throw new Error('User denied AppleScript execution');
+        }
+        this.daemon.logEvent(this.taskId, 'tool_call', {
+            tool: 'run_applescript',
+            scriptLength: normalizedScript.length,
+        });
+        try {
+            // Execute using osascript with multiple -e args (more robust than shell quoting)
+            const lines = normalizedScript
+                .split(/\r?\n/)
+                .map(line => line.trim())
+                .filter(line => line.length > 0);
+            if (lines.length === 0) {
+                throw new Error('AppleScript is empty after normalization');
+            }
+            const args = lines.flatMap(line => ['-e', line]);
+            const { stdout, stderr } = await execFileAsync('osascript', args, {
+                timeout: DEFAULT_TIMEOUT,
+                maxBuffer: 1024 * 1024, // 1MB buffer
+            });
+            const result = stdout.trim() || stderr.trim() || '(no output)';
+            this.daemon.logEvent(this.taskId, 'tool_result', {
+                tool: 'run_applescript',
+                success: true,
+                outputLength: result.length,
+            });
+            return {
+                success: true,
+                result,
+            };
+        }
+        catch (error) {
+            this.daemon.logEvent(this.taskId, 'tool_error', {
+                tool: 'run_applescript',
+                error: error.message,
+            });
+            // Extract meaningful error message from osascript errors
+            const errorMessage = error.stderr?.trim() || error.message || 'Unknown error';
+            throw new Error(`AppleScript execution failed: ${errorMessage}`);
+        }
+    }
+    /**
+     * Normalize AppleScript input for safer execution
+     */
+    normalizeAppleScript(input) {
+        let script = input;
+        let modified = false;
+        // Strip fenced code blocks if present
+        const fencedMatch = script.match(/```(?:applescript)?\s*([\s\S]*?)\s*```/i);
+        if (fencedMatch) {
+            script = fencedMatch[1];
+            modified = true;
+        }
+        // Replace smart quotes with straight quotes
+        const replaced = script
+            .replace(/[\u201C\u201D]/g, '"')
+            .replace(/[\u2018\u2019]/g, "'");
+        if (replaced !== script) {
+            script = replaced;
+            modified = true;
+        }
+        // Remove non-breaking spaces
+        const cleaned = script.replace(/\u00A0/g, ' ');
+        if (cleaned !== script) {
+            script = cleaned;
+            modified = true;
+        }
+        return { script: script.trim(), modified };
+    }
+    /**
+     * Static method to get tool definitions
+     */
+    static getToolDefinitions() {
+        return [
+            {
+                name: 'system_info',
+                description: 'Get system information including OS, CPU, memory, and user details',
+                input_schema: {
+                    type: 'object',
+                    properties: {},
+                    required: [],
+                },
+            },
+            {
+                name: 'read_clipboard',
+                description: 'Read the current contents of the system clipboard',
+                input_schema: {
+                    type: 'object',
+                    properties: {},
+                    required: [],
+                },
+            },
+            {
+                name: 'write_clipboard',
+                description: 'Write text to the system clipboard',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        text: {
+                            type: 'string',
+                            description: 'The text to write to the clipboard',
+                        },
+                    },
+                    required: ['text'],
+                },
+            },
+            {
+                name: 'take_screenshot',
+                description: 'Take a screenshot of the screen and save it to the workspace',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        filename: {
+                            type: 'string',
+                            description: 'Filename for the screenshot (optional, defaults to timestamp)',
+                        },
+                    },
+                    required: [],
+                },
+            },
+            {
+                name: 'open_application',
+                description: 'Open an application by name (e.g., "Safari", "Terminal", "Visual Studio Code")',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        appName: {
+                            type: 'string',
+                            description: 'Name of the application to open',
+                        },
+                    },
+                    required: ['appName'],
+                },
+            },
+            {
+                name: 'open_url',
+                description: 'Open a URL in the default web browser',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        url: {
+                            type: 'string',
+                            description: 'The URL to open',
+                        },
+                    },
+                    required: ['url'],
+                },
+            },
+            {
+                name: 'open_path',
+                description: 'Open a file or folder with the system default application',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Path to the file or folder to open',
+                        },
+                    },
+                    required: ['path'],
+                },
+            },
+            {
+                name: 'show_in_folder',
+                description: 'Show a file in the system file manager (Finder on macOS, Explorer on Windows)',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Path to the file to reveal',
+                        },
+                    },
+                    required: ['path'],
+                },
+            },
+            {
+                name: 'get_env',
+                description: 'Get the value of an environment variable',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            description: 'Name of the environment variable',
+                        },
+                    },
+                    required: ['name'],
+                },
+            },
+            {
+                name: 'get_app_paths',
+                description: 'Get common system paths (home, downloads, documents, desktop, temp)',
+                input_schema: {
+                    type: 'object',
+                    properties: {},
+                    required: [],
+                },
+            },
+            {
+                name: 'run_applescript',
+                description: 'Execute AppleScript code on macOS to automate applications and system tasks. ' +
+                    'Examples: control apps (Safari, Finder, Mail), manage windows, click UI elements, ' +
+                    'get/set system preferences, interact with files, send keystrokes. ' +
+                    'Only available on macOS.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        script: {
+                            type: 'string',
+                            description: 'The AppleScript code to execute. Can be a single line or multi-line script. ' +
+                                'Example: \'tell application "Finder" to get name of front window\'',
+                        },
+                    },
+                    required: ['script'],
+                },
+            },
+        ];
+    }
+}
+exports.SystemTools = SystemTools;