cowork-os 0.3.21 → 0.3.25

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

@@ -0,0 +1,231 @@
+"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.BoxTools = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const box_manager_1 = require("../../settings/box-manager");
+const box_api_1 = require("../../utils/box-api");
+const DEFAULT_FOLDER_ID = '0';
+class BoxTools {
+    constructor(workspace, daemon, taskId) {
+        this.workspace = workspace;
+        this.daemon = daemon;
+        this.taskId = taskId;
+    }
+    setWorkspace(workspace) {
+        this.workspace = workspace;
+    }
+    static isEnabled() {
+        return box_manager_1.BoxSettingsManager.loadSettings().enabled;
+    }
+    async requireApproval(summary, details) {
+        const approved = await this.daemon.requestApproval(this.taskId, 'external_service', summary, details);
+        if (!approved) {
+            throw new Error('User denied Box action');
+        }
+    }
+    resolveFilePath(inputPath) {
+        if (!this.workspace.permissions.read) {
+            throw new Error('Read permission not granted for uploads');
+        }
+        const workspaceRoot = path.resolve(this.workspace.path);
+        const allowedPaths = this.workspace.permissions.allowedPaths || [];
+        const canReadOutside = this.workspace.isTemp || this.workspace.permissions.unrestrictedFileAccess;
+        const isPathAllowed = (absolutePath) => {
+            if (allowedPaths.length === 0)
+                return false;
+            const normalizedPath = path.normalize(absolutePath);
+            return allowedPaths.some((allowed) => {
+                const normalizedAllowed = path.normalize(allowed);
+                return normalizedPath === normalizedAllowed || normalizedPath.startsWith(normalizedAllowed + path.sep);
+            });
+        };
+        const candidate = path.isAbsolute(inputPath)
+            ? path.normalize(inputPath)
+            : path.resolve(workspaceRoot, inputPath);
+        const relative = path.relative(workspaceRoot, candidate);
+        const isInsideWorkspace = !(relative.startsWith('..') || path.isAbsolute(relative));
+        if (!isInsideWorkspace && !canReadOutside && !isPathAllowed(candidate)) {
+            throw new Error('File path must be inside the workspace or in Allowed Paths');
+        }
+        if (!fs.existsSync(candidate)) {
+            throw new Error(`File not found: ${inputPath}`);
+        }
+        const stats = fs.statSync(candidate);
+        if (!stats.isFile()) {
+            throw new Error(`Path is not a file: ${inputPath}`);
+        }
+        return candidate;
+    }
+    async executeAction(input) {
+        const settings = box_manager_1.BoxSettingsManager.loadSettings();
+        if (!settings.enabled) {
+            throw new Error('Box integration is disabled. Enable it in Settings > Integrations > Box.');
+        }
+        const action = input.action;
+        if (!action) {
+            throw new Error('Missing required "action" parameter');
+        }
+        let result;
+        switch (action) {
+            case 'get_current_user': {
+                result = await (0, box_api_1.boxRequest)(settings, { method: 'GET', path: '/users/me' });
+                break;
+            }
+            case 'search': {
+                if (!input.query)
+                    throw new Error('Missing query for search');
+                result = await (0, box_api_1.boxRequest)(settings, {
+                    method: 'GET',
+                    path: '/search',
+                    query: {
+                        query: input.query,
+                        limit: input.limit,
+                        offset: input.offset,
+                        fields: input.fields,
+                        type: input.type,
+                        ancestor_folder_ids: input.ancestor_folder_ids,
+                        file_extensions: input.file_extensions,
+                        content_types: input.content_types,
+                        scope: input.scope,
+                    },
+                });
+                break;
+            }
+            case 'get_file': {
+                if (!input.file_id)
+                    throw new Error('Missing file_id for get_file');
+                result = await (0, box_api_1.boxRequest)(settings, {
+                    method: 'GET',
+                    path: `/files/${input.file_id}`,
+                    query: input.fields ? { fields: input.fields } : undefined,
+                });
+                break;
+            }
+            case 'get_folder': {
+                if (!input.folder_id)
+                    throw new Error('Missing folder_id for get_folder');
+                result = await (0, box_api_1.boxRequest)(settings, {
+                    method: 'GET',
+                    path: `/folders/${input.folder_id}`,
+                    query: input.fields ? { fields: input.fields } : undefined,
+                });
+                break;
+            }
+            case 'list_folder_items': {
+                const folderId = input.folder_id || DEFAULT_FOLDER_ID;
+                result = await (0, box_api_1.boxRequest)(settings, {
+                    method: 'GET',
+                    path: `/folders/${folderId}/items`,
+                    query: {
+                        limit: input.limit,
+                        offset: input.offset,
+                        fields: input.fields,
+                    },
+                });
+                break;
+            }
+            case 'create_folder': {
+                if (!input.name)
+                    throw new Error('Missing name for create_folder');
+                const parentId = input.parent_id || DEFAULT_FOLDER_ID;
+                await this.requireApproval('Create a Box folder', {
+                    action: 'create_folder',
+                    parent_id: parentId,
+                    name: input.name,
+                });
+                result = await (0, box_api_1.boxRequest)(settings, {
+                    method: 'POST',
+                    path: '/folders',
+                    body: {
+                        name: input.name,
+                        parent: { id: parentId },
+                    },
+                });
+                break;
+            }
+            case 'delete_file': {
+                if (!input.file_id)
+                    throw new Error('Missing file_id for delete_file');
+                await this.requireApproval('Delete a Box file', { action: 'delete_file', file_id: input.file_id });
+                result = await (0, box_api_1.boxRequest)(settings, { method: 'DELETE', path: `/files/${input.file_id}` });
+                break;
+            }
+            case 'delete_folder': {
+                if (!input.folder_id)
+                    throw new Error('Missing folder_id for delete_folder');
+                await this.requireApproval('Delete a Box folder', { action: 'delete_folder', folder_id: input.folder_id });
+                result = await (0, box_api_1.boxRequest)(settings, { method: 'DELETE', path: `/folders/${input.folder_id}` });
+                break;
+            }
+            case 'upload_file': {
+                if (!input.file_path)
+                    throw new Error('Missing file_path for upload_file');
+                const parentId = input.parent_id || DEFAULT_FOLDER_ID;
+                const resolved = this.resolveFilePath(input.file_path);
+                const data = fs.readFileSync(resolved);
+                const fileName = input.name || path.basename(resolved);
+                await this.requireApproval(`Upload file to Box: ${fileName}`, {
+                    action: 'upload_file',
+                    parent_id: parentId,
+                    file: fileName,
+                });
+                result = await (0, box_api_1.boxUploadFile)(settings, {
+                    fileName,
+                    parentId,
+                    data,
+                });
+                break;
+            }
+            default:
+                throw new Error(`Unsupported action: ${action}`);
+        }
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'box_action',
+            action,
+            status: result?.status,
+            hasData: result?.data ? true : false,
+        });
+        return {
+            success: true,
+            action,
+            status: result?.status,
+            data: result?.data,
+            raw: result?.raw,
+        };
+    }
+}
+exports.BoxTools = BoxTools;

package/dist/electron/electron/agent/tools/builtin-settings.js

@@ -95,6 +95,8 @@ const DEFAULT_SETTINGS = {
         },
     },
     toolOverrides: {},
+    toolTimeouts: {},
+    toolAutoApprove: {},
     version: '1.0.0',
 };
 /**
@@ -107,6 +109,12 @@ const TOOL_CATEGORIES = {
     edit_file: 'code',
     // Web fetch tools (high priority)
     web_fetch: 'webfetch',
+    notion_action: 'webfetch',
+    box_action: 'webfetch',
+    onedrive_action: 'webfetch',
+    google_drive_action: 'webfetch',
+    dropbox_action: 'webfetch',
+    sharepoint_action: 'webfetch',
     // Browser tools
     browser_navigate: 'browser',
     browser_screenshot: 'browser',
@@ -276,6 +284,8 @@ class BuiltinToolsSettingsManager {
                 ...settings.categories,
             },
             toolOverrides: settings.toolOverrides || {},
+            toolTimeouts: settings.toolTimeouts || {},
+            toolAutoApprove: settings.toolAutoApprove || {},
             version: settings.version || defaults.version,
         };
     }
@@ -318,6 +328,24 @@ class BuiltinToolsSettingsManager {
     static getToolCategory(toolName) {
         return TOOL_CATEGORIES[toolName] || null;
     }
+    /**
+     * Get per-tool timeout override (ms), if configured
+     */
+    static getToolTimeoutMs(toolName) {
+        const settings = this.loadSettings();
+        const timeout = settings.toolTimeouts?.[toolName];
+        if (typeof timeout !== 'number' || !Number.isFinite(timeout) || timeout <= 0) {
+            return null;
+        }
+        return Math.round(timeout);
+    }
+    /**
+     * Check if a tool should be auto-approved
+     */
+    static getToolAutoApprove(toolName) {
+        const settings = this.loadSettings();
+        return Boolean(settings.toolAutoApprove?.[toolName]);
+    }
     /**
      * Get all tool categories with their tools
      */

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

@@ -0,0 +1,237 @@
+"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.DropboxTools = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const dropbox_manager_1 = require("../../settings/dropbox-manager");
+const dropbox_api_1 = require("../../utils/dropbox-api");
+class DropboxTools {
+    constructor(workspace, daemon, taskId) {
+        this.workspace = workspace;
+        this.daemon = daemon;
+        this.taskId = taskId;
+    }
+    setWorkspace(workspace) {
+        this.workspace = workspace;
+    }
+    static isEnabled() {
+        return dropbox_manager_1.DropboxSettingsManager.loadSettings().enabled;
+    }
+    async requireApproval(summary, details) {
+        const approved = await this.daemon.requestApproval(this.taskId, 'external_service', summary, details);
+        if (!approved) {
+            throw new Error('User denied Dropbox action');
+        }
+    }
+    resolveFilePath(inputPath) {
+        if (!this.workspace.permissions.read) {
+            throw new Error('Read permission not granted for uploads');
+        }
+        const workspaceRoot = path.resolve(this.workspace.path);
+        const allowedPaths = this.workspace.permissions.allowedPaths || [];
+        const canReadOutside = this.workspace.isTemp || this.workspace.permissions.unrestrictedFileAccess;
+        const isPathAllowed = (absolutePath) => {
+            if (allowedPaths.length === 0)
+                return false;
+            const normalizedPath = path.normalize(absolutePath);
+            return allowedPaths.some((allowed) => {
+                const normalizedAllowed = path.normalize(allowed);
+                return normalizedPath === normalizedAllowed || normalizedPath.startsWith(normalizedAllowed + path.sep);
+            });
+        };
+        const candidate = path.isAbsolute(inputPath)
+            ? path.normalize(inputPath)
+            : path.resolve(workspaceRoot, inputPath);
+        const relative = path.relative(workspaceRoot, candidate);
+        const isInsideWorkspace = !(relative.startsWith('..') || path.isAbsolute(relative));
+        if (!isInsideWorkspace && !canReadOutside && !isPathAllowed(candidate)) {
+            throw new Error('File path must be inside the workspace or in Allowed Paths');
+        }
+        if (!fs.existsSync(candidate)) {
+            throw new Error(`File not found: ${inputPath}`);
+        }
+        const stats = fs.statSync(candidate);
+        if (!stats.isFile()) {
+            throw new Error(`Path is not a file: ${inputPath}`);
+        }
+        return candidate;
+    }
+    normalizeDropboxPath(pathValue) {
+        const trimmed = pathValue.trim();
+        if (!trimmed)
+            return '';
+        return trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+    }
+    async executeAction(input) {
+        const settings = dropbox_manager_1.DropboxSettingsManager.loadSettings();
+        if (!settings.enabled) {
+            throw new Error('Dropbox integration is disabled. Enable it in Settings > Integrations > Dropbox.');
+        }
+        const action = input.action;
+        if (!action) {
+            throw new Error('Missing required "action" parameter');
+        }
+        let result;
+        switch (action) {
+            case 'get_current_user': {
+                result = await (0, dropbox_api_1.dropboxRequest)(settings, { method: 'POST', path: '/users/get_current_account' });
+                break;
+            }
+            case 'list_folder': {
+                const pathValue = input.path ? this.normalizeDropboxPath(input.path) : '';
+                result = await (0, dropbox_api_1.dropboxRequest)(settings, {
+                    method: 'POST',
+                    path: '/files/list_folder',
+                    body: {
+                        path: pathValue,
+                        recursive: false,
+                        include_deleted: false,
+                        include_has_explicit_shared_members: false,
+                        include_mounted_folders: true,
+                        limit: input.limit,
+                    },
+                });
+                break;
+            }
+            case 'list_folder_continue': {
+                if (!input.cursor)
+                    throw new Error('Missing cursor for list_folder_continue');
+                result = await (0, dropbox_api_1.dropboxRequest)(settings, {
+                    method: 'POST',
+                    path: '/files/list_folder/continue',
+                    body: { cursor: input.cursor },
+                });
+                break;
+            }
+            case 'search': {
+                if (!input.query)
+                    throw new Error('Missing query for search');
+                result = await (0, dropbox_api_1.dropboxRequest)(settings, {
+                    method: 'POST',
+                    path: '/files/search_v2',
+                    body: {
+                        query: input.query,
+                        options: {
+                            path: input.path ? this.normalizeDropboxPath(input.path) : undefined,
+                            max_results: input.limit,
+                        },
+                    },
+                });
+                break;
+            }
+            case 'get_metadata': {
+                if (!input.path)
+                    throw new Error('Missing path for get_metadata');
+                result = await (0, dropbox_api_1.dropboxRequest)(settings, {
+                    method: 'POST',
+                    path: '/files/get_metadata',
+                    body: {
+                        path: this.normalizeDropboxPath(input.path),
+                        include_media_info: false,
+                        include_deleted: false,
+                        include_has_explicit_shared_members: false,
+                    },
+                });
+                break;
+            }
+            case 'create_folder': {
+                if (!input.path)
+                    throw new Error('Missing path for create_folder');
+                const folderPath = this.normalizeDropboxPath(input.path);
+                await this.requireApproval('Create a Dropbox folder', {
+                    action: 'create_folder',
+                    path: folderPath,
+                });
+                result = await (0, dropbox_api_1.dropboxRequest)(settings, {
+                    method: 'POST',
+                    path: '/files/create_folder_v2',
+                    body: {
+                        path: folderPath,
+                        autorename: true,
+                    },
+                });
+                break;
+            }
+            case 'delete_item': {
+                if (!input.path)
+                    throw new Error('Missing path for delete_item');
+                const deletePath = this.normalizeDropboxPath(input.path);
+                await this.requireApproval('Delete a Dropbox item', {
+                    action: 'delete_item',
+                    path: deletePath,
+                });
+                result = await (0, dropbox_api_1.dropboxRequest)(settings, {
+                    method: 'POST',
+                    path: '/files/delete_v2',
+                    body: { path: deletePath },
+                });
+                break;
+            }
+            case 'upload_file': {
+                if (!input.file_path)
+                    throw new Error('Missing file_path for upload_file');
+                const resolved = this.resolveFilePath(input.file_path);
+                const data = fs.readFileSync(resolved);
+                const fileName = input.name || path.basename(resolved);
+                const targetPath = input.path
+                    ? this.normalizeDropboxPath(input.path)
+                    : this.normalizeDropboxPath(`${input.parent_path || ''}/${fileName}`);
+                await this.requireApproval(`Upload file to Dropbox: ${fileName}`, {
+                    action: 'upload_file',
+                    path: targetPath,
+                });
+                result = await (0, dropbox_api_1.dropboxContentUpload)(settings, { path: targetPath, data });
+                break;
+            }
+            default:
+                throw new Error(`Unsupported action: ${action}`);
+        }
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'dropbox_action',
+            action,
+            status: result?.status,
+            hasData: result?.data ? true : false,
+        });
+        return {
+            success: true,
+            action,
+            status: result?.status,
+            data: result?.data,
+            raw: result?.raw,
+        };
+    }
+}
+exports.DropboxTools = DropboxTools;

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

@@ -168,10 +168,29 @@ class FileTools {
             throw new Error('Invalid path: path must be a non-empty string');
         }
         this.checkPermission('read');
-        const fullPath = this.resolvePath(relativePath, 'read');
-        const ext = path.extname(fullPath).toLowerCase();
+        let fullPath = this.resolvePath(relativePath, 'read');
+        let ext = path.extname(fullPath).toLowerCase();
         try {
-            const stats = await fs.stat(fullPath);
+            let stats;
+            try {
+                stats = await fs.stat(fullPath);
+            }
+            catch (error) {
+                if (this.isNotFoundError(error) && !path.isAbsolute(relativePath)) {
+                    const fallbackPath = await this.resolveCaseInsensitivePath(relativePath);
+                    if (fallbackPath && fallbackPath !== fullPath) {
+                        fullPath = fallbackPath;
+                        ext = path.extname(fullPath).toLowerCase();
+                        stats = await fs.stat(fullPath);
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+                else {
+                    throw error;
+                }
+            }
             // Handle DOCX files
             if (ext === '.docx') {
                 return await this.readDocxFile(fullPath, stats.size);
@@ -209,6 +228,50 @@ class FileTools {
             throw new Error(`Failed to read file: ${error.message}`);
         }
     }
+    isNotFoundError(error) {
+        const code = error?.code;
+        if (code === 'ENOENT' || code === 'ENOTDIR')
+            return true;
+        const message = String(error?.message || '');
+        return /no such file/i.test(message) || /not found/i.test(message);
+    }
+    /**
+     * Try resolving a path case-insensitively within the workspace.
+     * Only applies to workspace-relative paths without traversal.
+     */
+    async resolveCaseInsensitivePath(relativePath) {
+        const normalized = path.normalize(relativePath);
+        if (path.isAbsolute(normalized))
+            return null;
+        const parts = normalized.split(path.sep).filter(Boolean);
+        if (parts.some(part => part === '..'))
+            return null;
+        let current = this.workspace.path;
+        for (let i = 0; i < parts.length; i++) {
+            const segment = parts[i];
+            const lower = segment.toLowerCase();
+            let entries;
+            try {
+                entries = await fs.readdir(current, { withFileTypes: true });
+            }
+            catch {
+                return null;
+            }
+            if (entries.length > MAX_DIR_ENTRIES * 5) {
+                return null;
+            }
+            const match = entries.find(entry => entry.name.toLowerCase() === lower);
+            if (!match)
+                return null;
+            const nextPath = path.join(current, match.name);
+            const isLast = i === parts.length - 1;
+            if (!isLast && !match.isDirectory()) {
+                return null;
+            }
+            current = nextPath;
+        }
+        return current;
+    }
     /**
      * Read DOCX file and extract text content
      */