cowork-os 0.3.21 → 0.3.25

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

@@ -0,0 +1,237 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { Workspace } from '../../../shared/types';
+import { AgentDaemon } from '../daemon';
+import { DropboxSettingsManager } from '../../settings/dropbox-manager';
+import { dropboxRequest, dropboxContentUpload } from '../../utils/dropbox-api';
+
+type DropboxAction =
+  | 'get_current_user'
+  | 'list_folder'
+  | 'list_folder_continue'
+  | 'search'
+  | 'get_metadata'
+  | 'create_folder'
+  | 'delete_item'
+  | 'upload_file';
+
+interface DropboxActionInput {
+  action: DropboxAction;
+  path?: string;
+  query?: string;
+  limit?: number;
+  cursor?: string;
+  name?: string;
+  parent_path?: string;
+  file_path?: string;
+}
+
+export class DropboxTools {
+  constructor(
+    private workspace: Workspace,
+    private daemon: AgentDaemon,
+    private taskId: string
+  ) {}
+
+  setWorkspace(workspace: Workspace): void {
+    this.workspace = workspace;
+  }
+
+  static isEnabled(): boolean {
+    return DropboxSettingsManager.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 Dropbox 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;
+  }
+
+  private normalizeDropboxPath(pathValue: string): string {
+    const trimmed = pathValue.trim();
+    if (!trimmed) return '';
+    return trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+  }
+
+  async executeAction(input: DropboxActionInput): Promise<any> {
+    const settings = 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 dropboxRequest(settings, { method: 'POST', path: '/users/get_current_account' });
+        break;
+      }
+      case 'list_folder': {
+        const pathValue = input.path ? this.normalizeDropboxPath(input.path) : '';
+        result = await 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 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 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 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 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 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 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,
+    };
+  }
+}

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

@@ -178,11 +178,27 @@ export class FileTools {
     }
 
     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: { size: number };
+      try {
+        stats = await fs.stat(fullPath);
+      } catch (error: any) {
+        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') {
@@ -224,6 +240,53 @@ export class FileTools {
     }
   }
 
+  private isNotFoundError(error: any): boolean {
+    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.
+   */
+  private async resolveCaseInsensitivePath(relativePath: string): Promise<string | null> {
+    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: Array<{ name: string; isDirectory: () => boolean }>;
+      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
    */

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

@@ -0,0 +1,240 @@
+import { Workspace } from '../../../shared/types';
+import { AgentDaemon } from '../daemon';
+import { GoogleWorkspaceSettingsManager } from '../../settings/google-workspace-manager';
+import { gmailRequest } from '../../utils/gmail-api';
+
+type GmailAction =
+  | 'get_profile'
+  | 'list_messages'
+  | 'get_message'
+  | 'get_thread'
+  | 'list_labels'
+  | 'send_message'
+  | 'trash_message';
+
+interface GmailActionInput {
+  action: GmailAction;
+  query?: string;
+  page_size?: number;
+  page_token?: string;
+  label_ids?: string[];
+  include_spam_trash?: boolean;
+  message_id?: string;
+  thread_id?: string;
+  format?: 'full' | 'metadata' | 'minimal' | 'raw';
+  metadata_headers?: string[];
+  to?: string;
+  cc?: string;
+  bcc?: string;
+  subject?: string;
+  body?: string;
+  raw?: string;
+}
+
+function encodeMessage(raw: string): string {
+  return Buffer.from(raw)
+    .toString('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/, '');
+}
+
+function buildRawEmail(input: GmailActionInput): string {
+  const headers: string[] = [];
+  if (input.to) headers.push(`To: ${input.to}`);
+  if (input.cc) headers.push(`Cc: ${input.cc}`);
+  if (input.bcc) headers.push(`Bcc: ${input.bcc}`);
+  if (input.subject) headers.push(`Subject: ${input.subject}`);
+  headers.push('MIME-Version: 1.0');
+  headers.push('Content-Type: text/plain; charset="UTF-8"');
+  headers.push('Content-Transfer-Encoding: 7bit');
+
+  const body = input.body ?? '';
+  const message = `${headers.join('\r\n')}\r\n\r\n${body}`;
+  return encodeMessage(message);
+}
+
+export class GmailTools {
+  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 Gmail action');
+    }
+  }
+
+  async executeAction(input: GmailActionInput): 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;
+
+    try {
+      switch (action) {
+        case 'get_profile': {
+          result = await gmailRequest(settings, {
+            method: 'GET',
+            path: '/users/me/profile',
+          });
+          break;
+        }
+        case 'list_messages': {
+          result = await gmailRequest(settings, {
+            method: 'GET',
+            path: '/users/me/messages',
+            query: {
+              q: input.query,
+              maxResults: input.page_size,
+              pageToken: input.page_token,
+              includeSpamTrash: input.include_spam_trash,
+              labelIds: input.label_ids,
+            },
+          });
+          break;
+        }
+        case 'get_message': {
+          if (!input.message_id) throw new Error('Missing message_id for get_message');
+          result = await gmailRequest(settings, {
+            method: 'GET',
+            path: `/users/me/messages/${input.message_id}`,
+            query: {
+              format: input.format,
+              metadataHeaders: input.metadata_headers ? input.metadata_headers.join(',') : undefined,
+            },
+          });
+          break;
+        }
+        case 'get_thread': {
+          if (!input.thread_id) throw new Error('Missing thread_id for get_thread');
+          result = await gmailRequest(settings, {
+            method: 'GET',
+            path: `/users/me/threads/${input.thread_id}`,
+            query: {
+              format: input.format,
+              metadataHeaders: input.metadata_headers ? input.metadata_headers.join(',') : undefined,
+            },
+          });
+          break;
+        }
+        case 'list_labels': {
+          result = await gmailRequest(settings, {
+            method: 'GET',
+            path: '/users/me/labels',
+          });
+          break;
+        }
+        case 'send_message': {
+          if (!input.raw && !input.to) {
+            throw new Error('Missing to for send_message');
+          }
+          if (!input.raw && !input.body && !input.subject) {
+            throw new Error('Missing body or subject for send_message');
+          }
+
+          await this.requireApproval('Send a Gmail message', {
+            action: 'send_message',
+            to: input.to,
+            subject: input.subject,
+          });
+
+          const raw = input.raw || buildRawEmail(input);
+          const payload: Record<string, any> = { raw };
+          if (input.thread_id) {
+            payload.threadId = input.thread_id;
+          }
+
+          result = await gmailRequest(settings, {
+            method: 'POST',
+            path: '/users/me/messages/send',
+            body: payload,
+          });
+          break;
+        }
+        case 'trash_message': {
+          if (!input.message_id) throw new Error('Missing message_id for trash_message');
+          await this.requireApproval('Trash a Gmail message', {
+            action: 'trash_message',
+            message_id: input.message_id,
+          });
+          result = await gmailRequest(settings, {
+            method: 'POST',
+            path: `/users/me/messages/${input.message_id}/trash`,
+          });
+          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: 'gmail_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: 'gmail_action',
+      action,
+      status: result?.status,
+      hasData: result?.data ? true : false,
+    });
+
+    return {
+      success: true,
+      action,
+      status: result?.status,
+      data: result?.data,
+      raw: result?.raw,
+    };
+  }
+}