cowork-os 0.3.21 → 0.3.23

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/notion-tools.js

@@ -0,0 +1,312 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotionTools = void 0;
+const notion_manager_1 = require("../../settings/notion-manager");
+const notion_api_1 = require("../../utils/notion-api");
+class NotionTools {
+    constructor(workspace, daemon, taskId) {
+        this.workspace = workspace;
+        this.daemon = daemon;
+        this.taskId = taskId;
+    }
+    setWorkspace(workspace) {
+        this.workspace = workspace;
+    }
+    static isEnabled() {
+        return notion_manager_1.NotionSettingsManager.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 Notion action');
+        }
+    }
+    buildPagination(input) {
+        const body = {};
+        if (input.start_cursor)
+            body.start_cursor = input.start_cursor;
+        if (typeof input.page_size === 'number')
+            body.page_size = input.page_size;
+        return body;
+    }
+    buildTitle(title) {
+        if (!title)
+            return undefined;
+        const trimmed = title.trim();
+        if (!trimmed)
+            return undefined;
+        return [{ text: { content: trimmed } }];
+    }
+    buildParent(input) {
+        if (input.database_id) {
+            return { database_id: input.database_id };
+        }
+        if (input.parent_page_id) {
+            return { page_id: input.parent_page_id };
+        }
+        throw new Error('Missing parent identifier (database_id or parent_page_id)');
+    }
+    async executeAction(input) {
+        const settings = notion_manager_1.NotionSettingsManager.loadSettings();
+        if (!settings.enabled) {
+            throw new Error('Notion integration is disabled. Enable it in Settings > Integrations > Notion.');
+        }
+        const action = input.action;
+        if (!action) {
+            throw new Error('Missing required "action" parameter');
+        }
+        let result;
+        switch (action) {
+            case 'search': {
+                const body = input.payload ? { ...input.payload } : {};
+                if (!input.payload) {
+                    if (input.query)
+                        body.query = input.query;
+                    if (input.filter)
+                        body.filter = input.filter;
+                    if (input.sort)
+                        body.sort = input.sort;
+                    else if (input.sorts)
+                        body.sort = input.sorts;
+                    Object.assign(body, this.buildPagination(input));
+                }
+                result = await (0, notion_api_1.notionRequest)(settings, { method: 'POST', path: '/search', body });
+                break;
+            }
+            case 'list_users': {
+                const params = new URLSearchParams();
+                if (input.start_cursor)
+                    params.set('start_cursor', input.start_cursor);
+                if (typeof input.page_size === 'number')
+                    params.set('page_size', String(input.page_size));
+                const suffix = params.toString() ? `?${params.toString()}` : '';
+                result = await (0, notion_api_1.notionRequest)(settings, { method: 'GET', path: `/users${suffix}` });
+                break;
+            }
+            case 'get_user': {
+                if (!input.user_id)
+                    throw new Error('Missing user_id for get_user');
+                result = await (0, notion_api_1.notionRequest)(settings, { method: 'GET', path: `/users/${input.user_id}` });
+                break;
+            }
+            case 'get_page': {
+                if (!input.page_id)
+                    throw new Error('Missing page_id for get_page');
+                result = await (0, notion_api_1.notionRequest)(settings, { method: 'GET', path: `/pages/${input.page_id}` });
+                break;
+            }
+            case 'get_page_property': {
+                if (!input.page_id)
+                    throw new Error('Missing page_id for get_page_property');
+                if (!input.property_id)
+                    throw new Error('Missing property_id for get_page_property');
+                const params = new URLSearchParams();
+                if (input.start_cursor)
+                    params.set('start_cursor', input.start_cursor);
+                if (typeof input.page_size === 'number')
+                    params.set('page_size', String(input.page_size));
+                const suffix = params.toString() ? `?${params.toString()}` : '';
+                result = await (0, notion_api_1.notionRequest)(settings, { method: 'GET', path: `/pages/${input.page_id}/properties/${input.property_id}${suffix}` });
+                break;
+            }
+            case 'get_database': {
+                if (!input.database_id)
+                    throw new Error('Missing database_id for get_database');
+                result = await (0, notion_api_1.notionRequest)(settings, { method: 'GET', path: `/databases/${input.database_id}` });
+                break;
+            }
+            case 'get_block': {
+                if (!input.block_id)
+                    throw new Error('Missing block_id for get_block');
+                result = await (0, notion_api_1.notionRequest)(settings, { method: 'GET', path: `/blocks/${input.block_id}` });
+                break;
+            }
+            case 'get_block_children': {
+                if (!input.block_id)
+                    throw new Error('Missing block_id for get_block_children');
+                const params = new URLSearchParams();
+                if (input.start_cursor)
+                    params.set('start_cursor', input.start_cursor);
+                if (typeof input.page_size === 'number')
+                    params.set('page_size', String(input.page_size));
+                const suffix = params.toString() ? `?${params.toString()}` : '';
+                result = await (0, notion_api_1.notionRequest)(settings, { method: 'GET', path: `/blocks/${input.block_id}/children${suffix}` });
+                break;
+            }
+            case 'update_block': {
+                if (!input.block_id)
+                    throw new Error('Missing block_id for update_block');
+                const body = input.payload ? { ...input.payload } : {};
+                if (!input.payload) {
+                    if (typeof input.archived === 'boolean')
+                        body.archived = input.archived;
+                    if (input.block_type && input.block) {
+                        body[input.block_type] = input.block;
+                    }
+                    if (Object.keys(body).length === 0) {
+                        throw new Error('Missing update payload (archived or block content)');
+                    }
+                }
+                await this.requireApproval('Update a Notion block', {
+                    action: 'update_block',
+                    block_id: input.block_id,
+                });
+                result = await (0, notion_api_1.notionRequest)(settings, { method: 'PATCH', path: `/blocks/${input.block_id}`, body });
+                break;
+            }
+            case 'delete_block': {
+                if (!input.block_id)
+                    throw new Error('Missing block_id for delete_block');
+                await this.requireApproval('Delete a Notion block', {
+                    action: 'delete_block',
+                    block_id: input.block_id,
+                });
+                result = await (0, notion_api_1.notionRequest)(settings, { method: 'DELETE', path: `/blocks/${input.block_id}` });
+                break;
+            }
+            case 'get_data_source': {
+                if (!input.data_source_id)
+                    throw new Error('Missing data_source_id for get_data_source');
+                result = await (0, notion_api_1.notionRequest)(settings, { method: 'GET', path: `/data_sources/${input.data_source_id}` });
+                break;
+            }
+            case 'query_data_source': {
+                if (!input.data_source_id)
+                    throw new Error('Missing data_source_id for query_data_source');
+                const body = input.payload ? { ...input.payload } : {};
+                if (!input.payload) {
+                    if (input.filter)
+                        body.filter = input.filter;
+                    if (input.sorts)
+                        body.sorts = input.sorts;
+                    Object.assign(body, this.buildPagination(input));
+                }
+                result = await (0, notion_api_1.notionRequest)(settings, { method: 'POST', path: `/data_sources/${input.data_source_id}/query`, body });
+                break;
+            }
+            case 'create_page': {
+                const body = input.payload ? { ...input.payload } : {};
+                if (!input.payload) {
+                    body.parent = this.buildParent(input);
+                    if (!input.properties)
+                        throw new Error('Missing properties for create_page');
+                    body.properties = input.properties;
+                    if (input.children)
+                        body.children = input.children;
+                    if (input.icon)
+                        body.icon = input.icon;
+                    if (input.cover)
+                        body.cover = input.cover;
+                }
+                await this.requireApproval('Create a Notion page', {
+                    action: 'create_page',
+                    parent: body.parent,
+                });
+                result = await (0, notion_api_1.notionRequest)(settings, { method: 'POST', path: '/pages', body });
+                break;
+            }
+            case 'update_page': {
+                if (!input.page_id)
+                    throw new Error('Missing page_id for update_page');
+                const body = input.payload ? { ...input.payload } : {};
+                if (!input.payload) {
+                    if (input.properties)
+                        body.properties = input.properties;
+                    if (typeof input.archived === 'boolean')
+                        body.archived = input.archived;
+                    if (input.icon)
+                        body.icon = input.icon;
+                    if (input.cover)
+                        body.cover = input.cover;
+                    if (Object.keys(body).length === 0) {
+                        throw new Error('Missing update payload (properties, archived, icon, or cover)');
+                    }
+                }
+                await this.requireApproval('Update a Notion page', {
+                    action: 'update_page',
+                    page_id: input.page_id,
+                });
+                result = await (0, notion_api_1.notionRequest)(settings, { method: 'PATCH', path: `/pages/${input.page_id}`, body });
+                break;
+            }
+            case 'append_blocks': {
+                if (!input.block_id)
+                    throw new Error('Missing block_id for append_blocks');
+                const body = input.payload ? { ...input.payload } : {};
+                if (!input.payload) {
+                    if (!input.children || input.children.length === 0) {
+                        throw new Error('Missing children for append_blocks');
+                    }
+                    body.children = input.children;
+                }
+                await this.requireApproval('Append blocks in Notion', {
+                    action: 'append_blocks',
+                    block_id: input.block_id,
+                    count: Array.isArray(body.children) ? body.children.length : undefined,
+                });
+                result = await (0, notion_api_1.notionRequest)(settings, { method: 'PATCH', path: `/blocks/${input.block_id}/children`, body });
+                break;
+            }
+            case 'create_data_source': {
+                const body = input.payload ? { ...input.payload } : {};
+                if (!input.payload) {
+                    if (!input.parent_page_id)
+                        throw new Error('Missing parent_page_id for create_data_source');
+                    if (!input.properties)
+                        throw new Error('Missing properties for create_data_source');
+                    const title = this.buildTitle(input.title);
+                    if (!title)
+                        throw new Error('Missing title for create_data_source');
+                    body.parent = { page_id: input.parent_page_id };
+                    body.title = title;
+                    body.properties = input.properties;
+                    if (typeof input.is_inline === 'boolean')
+                        body.is_inline = input.is_inline;
+                }
+                await this.requireApproval('Create a Notion data source', {
+                    action: 'create_data_source',
+                    parent: body.parent,
+                });
+                result = await (0, notion_api_1.notionRequest)(settings, { method: 'POST', path: '/data_sources', body });
+                break;
+            }
+            case 'update_data_source': {
+                if (!input.data_source_id)
+                    throw new Error('Missing data_source_id for update_data_source');
+                const body = input.payload ? { ...input.payload } : {};
+                if (!input.payload) {
+                    if (input.properties)
+                        body.properties = input.properties;
+                    const title = this.buildTitle(input.title);
+                    if (title)
+                        body.title = title;
+                    if (Object.keys(body).length === 0) {
+                        throw new Error('Missing update payload (properties or title)');
+                    }
+                }
+                await this.requireApproval('Update a Notion data source', {
+                    action: 'update_data_source',
+                    data_source_id: input.data_source_id,
+                });
+                result = await (0, notion_api_1.notionRequest)(settings, { method: 'PATCH', path: `/data_sources/${input.data_source_id}`, body });
+                break;
+            }
+            default:
+                throw new Error(`Unsupported action: ${action}`);
+        }
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'notion_action',
+            action,
+            status: result?.status,
+            hasData: !!result?.data,
+        });
+        return {
+            success: true,
+            action,
+            status: result?.status,
+            data: result?.data,
+            raw: result?.raw,
+        };
+    }
+}
+exports.NotionTools = NotionTools;