cowork-os 0.3.21 → 0.3.23

package/src/electron/agent/tools/google-drive-tools.ts

@@ -0,0 +1,228 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import mime from 'mime-types';
+import { Workspace } from '../../../shared/types';
+import { AgentDaemon } from '../daemon';
+import { GoogleDriveSettingsManager } from '../../settings/google-drive-manager';
+import { googleDriveRequest, googleDriveUpload } from '../../utils/google-drive-api';
+
+type GoogleDriveAction =
+  | 'get_current_user'
+  | 'list_files'
+  | 'get_file'
+  | 'create_folder'
+  | 'upload_file'
+  | 'delete_file';
+
+interface GoogleDriveActionInput {
+  action: GoogleDriveAction;
+  query?: string;
+  page_size?: number;
+  page_token?: string;
+  fields?: string;
+  file_id?: string;
+  parent_id?: string;
+  name?: string;
+  file_path?: string;
+}
+
+const DEFAULT_LIST_FIELDS =
+  'nextPageToken, files(id,name,mimeType,modifiedTime,parents,webViewLink,size)';
+const DEFAULT_FILE_FIELDS =
+  'id,name,mimeType,modifiedTime,parents,webViewLink,size';
+
+export class GoogleDriveTools {
+  constructor(
+    private workspace: Workspace,
+    private daemon: AgentDaemon,
+    private taskId: string
+  ) {}
+
+  setWorkspace(workspace: Workspace): void {
+    this.workspace = workspace;
+  }
+
+  static isEnabled(): boolean {
+    return GoogleDriveSettingsManager.loadSettings().enabled;
+  }
+
+  private async requireApproval(summary: string, details: Record<string, unknown>): Promise<void> {
+    const approved = await this.daemon.requestApproval(
+      this.taskId,
+      'external_service',
+      summary,
+      details
+    );
+
+    if (!approved) {
+      throw new Error('User denied Google Drive action');
+    }
+  }
+
+  private resolveFilePath(inputPath: string): string {
+    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: string): boolean => {
+      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: GoogleDriveActionInput): Promise<any> {
+    const settings = 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 googleDriveRequest(settings, {
+          method: 'GET',
+          path: '/about',
+          query: { fields: 'user' },
+        });
+        break;
+      }
+      case 'list_files': {
+        const query = input.query || 'trashed = false';
+        result = await 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 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 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.lookup(fileName) || 'application/octet-stream') as string;
+        await this.requireApproval(`Upload file to Google Drive: ${fileName}`, {
+          action: 'upload_file',
+          parent_id: input.parent_id || 'root',
+          file: fileName,
+        });
+        const created = await 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 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 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,
+    };
+  }
+}

package/src/electron/agent/tools/notion-tools.ts

@@ -0,0 +1,330 @@
+import { Workspace } from '../../../shared/types';
+import { AgentDaemon } from '../daemon';
+import { NotionSettingsManager } from '../../settings/notion-manager';
+import { notionRequest } from '../../utils/notion-api';
+
+type NotionAction =
+  | 'search'
+  | 'list_users'
+  | 'get_user'
+  | 'get_page'
+  | 'get_page_property'
+  | 'get_database'
+  | 'get_block'
+  | 'get_block_children'
+  | 'update_block'
+  | 'delete_block'
+  | 'create_page'
+  | 'update_page'
+  | 'append_blocks'
+  | 'query_data_source'
+  | 'get_data_source'
+  | 'create_data_source'
+  | 'update_data_source';
+
+interface NotionActionInput {
+  action: NotionAction;
+  query?: string;
+  user_id?: string;
+  page_id?: string;
+  property_id?: string;
+  block_id?: string;
+  block_type?: string;
+  block?: Record<string, any>;
+  data_source_id?: string;
+  database_id?: string;
+  parent_page_id?: string;
+  properties?: Record<string, any>;
+  children?: any[];
+  filter?: any;
+  sort?: any;
+  sorts?: any[];
+  start_cursor?: string;
+  page_size?: number;
+  archived?: boolean;
+  icon?: any;
+  cover?: any;
+  title?: string;
+  is_inline?: boolean;
+  payload?: Record<string, any>;
+}
+
+export class NotionTools {
+  constructor(
+    private workspace: Workspace,
+    private daemon: AgentDaemon,
+    private taskId: string
+  ) {}
+
+  setWorkspace(workspace: Workspace): void {
+    this.workspace = workspace;
+  }
+
+  static isEnabled(): boolean {
+    return NotionSettingsManager.loadSettings().enabled;
+  }
+
+  private async requireApproval(summary: string, details: Record<string, unknown>): Promise<void> {
+    const approved = await this.daemon.requestApproval(
+      this.taskId,
+      'external_service',
+      summary,
+      details
+    );
+
+    if (!approved) {
+      throw new Error('User denied Notion action');
+    }
+  }
+
+  private buildPagination(input: NotionActionInput): Record<string, any> {
+    const body: Record<string, any> = {};
+    if (input.start_cursor) body.start_cursor = input.start_cursor;
+    if (typeof input.page_size === 'number') body.page_size = input.page_size;
+    return body;
+  }
+
+  private buildTitle(title?: string): Array<{ text: { content: string } }> | undefined {
+    if (!title) return undefined;
+    const trimmed = title.trim();
+    if (!trimmed) return undefined;
+    return [{ text: { content: trimmed } }];
+  }
+
+  private buildParent(input: NotionActionInput): Record<string, string> {
+    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: NotionActionInput): Promise<any> {
+    const settings = 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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,
+    };
+  }
+}