cowork-os 0.3.21 → 0.3.25

package/dist/electron/electron/agent/tools/google-drive-tools.js

@@ -0,0 +1,227 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleDriveTools = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const mime_types_1 = __importDefault(require("mime-types"));
+const google_drive_manager_1 = require("../../settings/google-drive-manager");
+const google_drive_api_1 = require("../../utils/google-drive-api");
+const DEFAULT_LIST_FIELDS = 'nextPageToken, files(id,name,mimeType,modifiedTime,parents,webViewLink,size)';
+const DEFAULT_FILE_FIELDS = 'id,name,mimeType,modifiedTime,parents,webViewLink,size';
+class GoogleDriveTools {
+    constructor(workspace, daemon, taskId) {
+        this.workspace = workspace;
+        this.daemon = daemon;
+        this.taskId = taskId;
+    }
+    setWorkspace(workspace) {
+        this.workspace = workspace;
+    }
+    static isEnabled() {
+        return google_drive_manager_1.GoogleDriveSettingsManager.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 Google Drive 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 = google_drive_manager_1.GoogleDriveSettingsManager.loadSettings();
+        if (!settings.enabled) {
+            throw new Error('Google Drive integration is disabled. Enable it in Settings > Integrations > Google Drive.');
+        }
+        const action = input.action;
+        if (!action) {
+            throw new Error('Missing required "action" parameter');
+        }
+        let result;
+        switch (action) {
+            case 'get_current_user': {
+                result = await (0, google_drive_api_1.googleDriveRequest)(settings, {
+                    method: 'GET',
+                    path: '/about',
+                    query: { fields: 'user' },
+                });
+                break;
+            }
+            case 'list_files': {
+                const query = input.query || 'trashed = false';
+                result = await (0, google_drive_api_1.googleDriveRequest)(settings, {
+                    method: 'GET',
+                    path: '/files',
+                    query: {
+                        q: query,
+                        pageSize: input.page_size,
+                        pageToken: input.page_token,
+                        fields: input.fields || DEFAULT_LIST_FIELDS,
+                    },
+                });
+                break;
+            }
+            case 'get_file': {
+                if (!input.file_id)
+                    throw new Error('Missing file_id for get_file');
+                result = await (0, google_drive_api_1.googleDriveRequest)(settings, {
+                    method: 'GET',
+                    path: `/files/${input.file_id}`,
+                    query: {
+                        fields: input.fields || DEFAULT_FILE_FIELDS,
+                    },
+                });
+                break;
+            }
+            case 'create_folder': {
+                if (!input.name)
+                    throw new Error('Missing name for create_folder');
+                await this.requireApproval('Create a Google Drive folder', {
+                    action: 'create_folder',
+                    parent_id: input.parent_id || 'root',
+                    name: input.name,
+                });
+                result = await (0, google_drive_api_1.googleDriveRequest)(settings, {
+                    method: 'POST',
+                    path: '/files',
+                    query: { fields: DEFAULT_FILE_FIELDS },
+                    body: {
+                        name: input.name,
+                        mimeType: 'application/vnd.google-apps.folder',
+                        parents: input.parent_id ? [input.parent_id] : undefined,
+                    },
+                });
+                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 contentType = (mime_types_1.default.lookup(fileName) || 'application/octet-stream');
+                await this.requireApproval(`Upload file to Google Drive: ${fileName}`, {
+                    action: 'upload_file',
+                    parent_id: input.parent_id || 'root',
+                    file: fileName,
+                });
+                const created = await (0, google_drive_api_1.googleDriveRequest)(settings, {
+                    method: 'POST',
+                    path: '/files',
+                    query: { fields: DEFAULT_FILE_FIELDS },
+                    body: {
+                        name: fileName,
+                        parents: input.parent_id ? [input.parent_id] : undefined,
+                    },
+                });
+                const fileId = created.data?.id;
+                if (!fileId) {
+                    throw new Error('Failed to create Google Drive file record');
+                }
+                const uploaded = await (0, google_drive_api_1.googleDriveUpload)(settings, fileId, data, contentType);
+                result = {
+                    status: uploaded.status,
+                    data: uploaded.data || created.data,
+                    raw: uploaded.raw,
+                };
+                break;
+            }
+            case 'delete_file': {
+                if (!input.file_id)
+                    throw new Error('Missing file_id for delete_file');
+                await this.requireApproval('Delete a Google Drive file', {
+                    action: 'delete_file',
+                    file_id: input.file_id,
+                });
+                result = await (0, google_drive_api_1.googleDriveRequest)(settings, {
+                    method: 'DELETE',
+                    path: `/files/${input.file_id}`,
+                });
+                break;
+            }
+            default:
+                throw new Error(`Unsupported action: ${action}`);
+        }
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'google_drive_action',
+            action,
+            status: result?.status,
+            hasData: result?.data ? true : false,
+        });
+        return {
+            success: true,
+            action,
+            status: result?.status,
+            data: result?.data,
+            raw: result?.raw,
+        };
+    }
+}
+exports.GoogleDriveTools = GoogleDriveTools;

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

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GrepTools = void 0;
 const fs = __importStar(require("fs"));
+const fsPromises = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 /**
  * GrepTools provides powerful regex-based content search
@@ -61,6 +62,7 @@ class GrepTools {
                 name: 'grep',
                 description: 'Powerful regex-based content search across files. ' +
                     'Supports full regex syntax (e.g., "async function.*fetch", "class\\s+\\w+"). ' +
+                    'Searches text files only; binary formats like PDF/DOCX are skipped. ' +
                     'Use this to find code patterns, function definitions, imports, etc. ' +
                     'PREFERRED over search_files for content search.',
                 input_schema: {
@@ -110,6 +112,17 @@ class GrepTools {
             message: `Grep search: "${pattern}"${searchPath ? ` in ${searchPath}` : ''}${globPattern ? ` (${globPattern})` : ''}`,
         });
         try {
+            if ((await this.isDocumentHeavyWorkspace()) && (!globPattern || /\.(pdf|docx)\b/i.test(globPattern))) {
+                return {
+                    success: true,
+                    pattern,
+                    matches: [],
+                    totalMatches: 0,
+                    filesSearched: 0,
+                    truncated: false,
+                    warning: 'Workspace appears document-heavy (PDF/DOCX). The grep tool only searches text files. Use read_file for those documents.',
+                };
+            }
             // Compile regex
             let regex;
             try {
@@ -289,7 +302,8 @@ class GrepTools {
                     }
                     // Apply glob filter if specified
                     if (globRegex) {
-                        if (!globRegex.test(relativePath) && !globRegex.test(entry.name)) {
+                        const normalizedRelative = relativePath.split(path.sep).join('/');
+                        if (!globRegex.test(normalizedRelative) && !globRegex.test(entry.name)) {
                             continue;
                         }
                     }
@@ -354,16 +368,8 @@ class GrepTools {
      * Convert glob pattern to regex
      */
     globToRegex(pattern) {
-        // Handle brace expansion
         const expandedPatterns = this.expandBraces(pattern);
-        const regexParts = expandedPatterns.map((p) => {
-            let regex = p
-                .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-                .replace(/\\\*\\\*/g, '.*')
-                .replace(/\\\*/g, '[^/]*')
-                .replace(/\\\?/g, '[^/]');
-            return regex;
-        });
+        const regexParts = expandedPatterns.map((p) => this.globPatternToRegex(p));
         const combined = regexParts.length > 1 ? `(${regexParts.join('|')})` : regexParts[0];
         return new RegExp(`^${combined}$`, 'i');
     }
@@ -383,5 +389,79 @@ class GrepTools {
         }
         return results;
     }
+    /**
+     * Heuristic: detect workspaces dominated by PDF/DOCX files
+     */
+    async isDocumentHeavyWorkspace() {
+        try {
+            const entries = await fsPromises.readdir(this.workspace.path, { withFileTypes: true });
+            let fileCount = 0;
+            let docCount = 0;
+            const maxEntries = 200;
+            for (const entry of entries) {
+                if (fileCount >= maxEntries)
+                    break;
+                if (!entry.isFile())
+                    continue;
+                fileCount++;
+                const ext = path.extname(entry.name).toLowerCase();
+                if (ext === '.pdf' || ext === '.docx') {
+                    docCount++;
+                }
+            }
+            if (fileCount < 5)
+                return false;
+            return docCount / fileCount >= 0.5;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Convert a glob pattern to a regex string (without delimiters)
+     */
+    globPatternToRegex(pattern) {
+        let regex = '';
+        let i = 0;
+        while (i < pattern.length) {
+            const char = pattern[i];
+            if (char === '*') {
+                const isDoubleStar = pattern[i + 1] === '*';
+                if (isDoubleStar) {
+                    i += 2;
+                    if (pattern[i] === '/') {
+                        regex += '(?:.*/)?';
+                        i += 1;
+                    }
+                    else {
+                        regex += '.*';
+                    }
+                }
+                else {
+                    regex += '[^/]*';
+                    i += 1;
+                }
+                continue;
+            }
+            if (char === '?') {
+                regex += '[^/]';
+                i += 1;
+                continue;
+            }
+            if ('+^${}()|[]\\.'.includes(char)) {
+                regex += `\\${char}`;
+                i += 1;
+                continue;
+            }
+            if (char === '/') {
+                regex += '/';
+                i += 1;
+                continue;
+            }
+            regex += char;
+            i += 1;
+        }
+        return regex;
+    }
 }
 exports.GrepTools = GrepTools;

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

@@ -51,9 +51,19 @@ class ImageTools {
             }
         }
         else {
-            this.daemon.logEvent(this.taskId, 'error', {
+            const payload = {
                 action: 'generate_image',
                 error: result.error,
+            };
+            if (result.error?.includes('Gemini API key not configured')) {
+                payload.actionHint = {
+                    type: 'open_settings',
+                    label: 'Set up Gemini API key',
+                    target: 'gemini',
+                };
+            }
+            this.daemon.logEvent(this.taskId, 'error', {
+                ...payload,
             });
         }
         return result;