cowork-os 0.3.21 → 0.3.25

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

@@ -0,0 +1,258 @@
+import { Workspace } from '../../../shared/types';
+import { AgentDaemon } from '../daemon';
+import { GoogleWorkspaceSettingsManager } from '../../settings/google-workspace-manager';
+import { googleCalendarRequest } from '../../utils/google-calendar-api';
+
+type CalendarAction =
+  | 'list_calendars'
+  | 'list_events'
+  | 'get_event'
+  | 'create_event'
+  | 'update_event'
+  | 'delete_event';
+
+interface GoogleCalendarActionInput {
+  action: CalendarAction;
+  calendar_id?: string;
+  event_id?: string;
+  query?: string;
+  time_min?: string;
+  time_max?: string;
+  max_results?: number;
+  page_token?: string;
+  single_events?: boolean;
+  order_by?: 'startTime' | 'updated';
+  summary?: string;
+  description?: string;
+  location?: string;
+  start?: string | { dateTime?: string; date?: string; timeZone?: string };
+  end?: string | { dateTime?: string; date?: string; timeZone?: string };
+  attendees?: Array<string | { email: string }>;
+  time_zone?: string;
+  payload?: Record<string, any>;
+}
+
+function buildAttendees(attendees?: Array<string | { email: string }>): Array<{ email: string }> | undefined {
+  if (!attendees || attendees.length === 0) return undefined;
+  return attendees.map((attendee) => {
+    if (typeof attendee === 'string') {
+      return { email: attendee };
+    }
+    return { email: attendee.email };
+  }).filter((attendee) => attendee.email);
+}
+
+function buildEventPayload(input: GoogleCalendarActionInput): Record<string, any> {
+  if (input.payload) {
+    return input.payload;
+  }
+
+  if (!input.summary || !input.start || !input.end) {
+    throw new Error('Missing summary/start/end for calendar event');
+  }
+
+  const event: Record<string, any> = {
+    summary: input.summary,
+  };
+
+  if (input.description) event.description = input.description;
+  if (input.location) event.location = input.location;
+
+  const timeZone = input.time_zone;
+
+  const buildDateField = (value: string | { dateTime?: string; date?: string; timeZone?: string }) => {
+    if (typeof value === 'string') {
+      return {
+        dateTime: value,
+        timeZone,
+      };
+    }
+    return {
+      ...value,
+      timeZone: value.timeZone || timeZone,
+    };
+  };
+
+  event.start = buildDateField(input.start);
+  event.end = buildDateField(input.end);
+
+  const attendees = buildAttendees(input.attendees);
+  if (attendees) {
+    event.attendees = attendees;
+  }
+
+  return event;
+}
+
+export class GoogleCalendarTools {
+  constructor(
+    private workspace: Workspace,
+    private daemon: AgentDaemon,
+    private taskId: string
+  ) {}
+
+  setWorkspace(workspace: Workspace): void {
+    this.workspace = workspace;
+  }
+
+  static isEnabled(): boolean {
+    return GoogleWorkspaceSettingsManager.loadSettings().enabled;
+  }
+
+  private formatAuthError(error: unknown): string | null {
+    const message = String((error as any)?.message ?? '');
+    const status = (error as any)?.status;
+    if (status === 401) {
+      return 'Google Workspace authorization failed (401). Reconnect in Settings > Integrations > Google Workspace.';
+    }
+    if (/token refresh failed|refresh token not configured|access token not configured|access token expired/i.test(message)) {
+      return `Google Workspace authorization error: ${message}`;
+    }
+    return null;
+  }
+
+  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 Calendar action');
+    }
+  }
+
+  async executeAction(input: GoogleCalendarActionInput): Promise<any> {
+    const settings = GoogleWorkspaceSettingsManager.loadSettings();
+    if (!settings.enabled) {
+      throw new Error('Google Workspace integration is disabled. Enable it in Settings > Integrations > Google Workspace.');
+    }
+
+    const action = input.action;
+    if (!action) {
+      throw new Error('Missing required "action" parameter');
+    }
+
+    const calendarId = input.calendar_id || 'primary';
+    let result;
+
+    try {
+      switch (action) {
+        case 'list_calendars': {
+          result = await googleCalendarRequest(settings, {
+            method: 'GET',
+            path: '/users/me/calendarList',
+            query: {
+              maxResults: input.max_results,
+              pageToken: input.page_token,
+            },
+          });
+          break;
+        }
+        case 'list_events': {
+          result = await googleCalendarRequest(settings, {
+            method: 'GET',
+            path: `/calendars/${encodeURIComponent(calendarId)}/events`,
+            query: {
+              q: input.query,
+              timeMin: input.time_min,
+              timeMax: input.time_max,
+              maxResults: input.max_results,
+              pageToken: input.page_token,
+              singleEvents: input.single_events ?? true,
+              orderBy: input.order_by,
+            },
+          });
+          break;
+        }
+        case 'get_event': {
+          if (!input.event_id) throw new Error('Missing event_id for get_event');
+          result = await googleCalendarRequest(settings, {
+            method: 'GET',
+            path: `/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(input.event_id)}`,
+          });
+          break;
+        }
+        case 'create_event': {
+          const eventPayload = buildEventPayload(input);
+          await this.requireApproval('Create a Google Calendar event', {
+            action: 'create_event',
+            calendar_id: calendarId,
+            summary: eventPayload.summary,
+          });
+          result = await googleCalendarRequest(settings, {
+            method: 'POST',
+            path: `/calendars/${encodeURIComponent(calendarId)}/events`,
+            body: eventPayload,
+          });
+          break;
+        }
+        case 'update_event': {
+          if (!input.event_id) throw new Error('Missing event_id for update_event');
+          const updatePayload = buildEventPayload(input);
+          await this.requireApproval('Update a Google Calendar event', {
+            action: 'update_event',
+            calendar_id: calendarId,
+            event_id: input.event_id,
+            summary: updatePayload.summary,
+          });
+          result = await googleCalendarRequest(settings, {
+            method: 'PATCH',
+            path: `/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(input.event_id)}`,
+            body: updatePayload,
+          });
+          break;
+        }
+        case 'delete_event': {
+          if (!input.event_id) throw new Error('Missing event_id for delete_event');
+          await this.requireApproval('Delete a Google Calendar event', {
+            action: 'delete_event',
+            calendar_id: calendarId,
+            event_id: input.event_id,
+          });
+          result = await googleCalendarRequest(settings, {
+            method: 'DELETE',
+            path: `/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(input.event_id)}`,
+          });
+          break;
+        }
+        default:
+          throw new Error(`Unsupported action: ${action}`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const authMessage = this.formatAuthError(error);
+      const finalMessage = authMessage ?? message;
+      this.daemon.logEvent(this.taskId, 'tool_error', {
+        tool: 'calendar_action',
+        action,
+        message: finalMessage,
+        status: (error as any)?.status,
+      });
+      if (authMessage) {
+        throw new Error(authMessage);
+      }
+      if (error instanceof Error) {
+        throw error;
+      }
+      throw new Error(message);
+    }
+
+    this.daemon.logEvent(this.taskId, 'tool_result', {
+      tool: 'calendar_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/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 { GoogleWorkspaceSettingsManager } from '../../settings/google-workspace-manager';
+import { googleDriveRequest, googleDriveUpload } from '../../utils/google-workspace-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 GoogleWorkspaceSettingsManager.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 = GoogleWorkspaceSettingsManager.loadSettings();
+    if (!settings.enabled) {
+      throw new Error('Google Workspace integration is disabled. Enable it in Settings > Integrations > Google Workspace.');
+    }
+
+    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/grep-tools.ts

@@ -1,4 +1,5 @@
 import * as fs from 'fs';
+import * as fsPromises from 'fs/promises';
 import * as path from 'path';
 import { Workspace } from '../../../shared/types';
 import { AgentDaemon } from '../daemon';
@@ -32,6 +33,7 @@ export class GrepTools {
         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: {
@@ -99,6 +101,7 @@ export class GrepTools {
     filesSearched: number;
     truncated: boolean;
     error?: string;
+    warning?: string;
   }> {
     const {
       pattern,
@@ -115,6 +118,18 @@ export class GrepTools {
     });
 
     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: RegExp;
       try {
@@ -327,7 +342,8 @@ export 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;
             }
           }
@@ -395,18 +411,8 @@ export class GrepTools {
    * Convert glob pattern to regex
    */
   private globToRegex(pattern: string): RegExp {
-    // 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');
   }
@@ -429,4 +435,83 @@ export class GrepTools {
 
     return results;
   }
+
+  /**
+   * Heuristic: detect workspaces dominated by PDF/DOCX files
+   */
+  private async isDocumentHeavyWorkspace(): Promise<boolean> {
+    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)
+   */
+  private globPatternToRegex(pattern: string): string {
+    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;
+  }
 }

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

@@ -64,9 +64,19 @@ export class ImageTools {
         });
       }
     } else {
-      this.daemon.logEvent(this.taskId, 'error', {
+      const payload: Record<string, any> = {
         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,
       });
     }