cowork-os 0.3.21 → 0.3.25

package/src/electron/settings/notion-manager.ts

@@ -0,0 +1,60 @@
+/**
+ * Notion Settings Manager
+ *
+ * Stores Notion integration settings in encrypted database.
+ */
+
+import { SecureSettingsRepository } from '../database/SecureSettingsRepository';
+import { NotionSettingsData } from '../../shared/types';
+import { DEFAULT_NOTION_VERSION } from '../utils/notion-api';
+
+const DEFAULT_SETTINGS: NotionSettingsData = {
+  enabled: false,
+  notionVersion: DEFAULT_NOTION_VERSION,
+  timeoutMs: 20000,
+};
+
+export class NotionSettingsManager {
+  private static cachedSettings: NotionSettingsData | null = null;
+
+  static loadSettings(): NotionSettingsData {
+    if (this.cachedSettings) {
+      return this.cachedSettings;
+    }
+
+    let settings: NotionSettingsData = { ...DEFAULT_SETTINGS };
+
+    try {
+      if (SecureSettingsRepository.isInitialized()) {
+        const repository = SecureSettingsRepository.getInstance();
+        const stored = repository.load<NotionSettingsData>('notion');
+        if (stored) {
+          settings = { ...DEFAULT_SETTINGS, ...stored };
+        }
+      }
+    } catch (error) {
+      console.error('[NotionSettingsManager] Failed to load settings:', error);
+    }
+
+    this.cachedSettings = settings;
+    return settings;
+  }
+
+  static saveSettings(settings: NotionSettingsData): void {
+    try {
+      if (!SecureSettingsRepository.isInitialized()) {
+        throw new Error('SecureSettingsRepository not initialized');
+      }
+      const repository = SecureSettingsRepository.getInstance();
+      repository.save('notion', settings);
+      this.cachedSettings = settings;
+      console.log('[NotionSettingsManager] Settings saved');
+    } catch (error) {
+      console.error('[NotionSettingsManager] Failed to save settings:', error);
+    }
+  }
+
+  static clearCache(): void {
+    this.cachedSettings = null;
+  }
+}

package/src/electron/settings/onedrive-manager.ts

@@ -0,0 +1,58 @@
+/**
+ * OneDrive Settings Manager
+ *
+ * Stores OneDrive integration settings in encrypted database.
+ */
+
+import { SecureSettingsRepository } from '../database/SecureSettingsRepository';
+import { OneDriveSettingsData } from '../../shared/types';
+
+const DEFAULT_SETTINGS: OneDriveSettingsData = {
+  enabled: false,
+  timeoutMs: 20000,
+};
+
+export class OneDriveSettingsManager {
+  private static cachedSettings: OneDriveSettingsData | null = null;
+
+  static loadSettings(): OneDriveSettingsData {
+    if (this.cachedSettings) {
+      return this.cachedSettings;
+    }
+
+    let settings: OneDriveSettingsData = { ...DEFAULT_SETTINGS };
+
+    try {
+      if (SecureSettingsRepository.isInitialized()) {
+        const repository = SecureSettingsRepository.getInstance();
+        const stored = repository.load<OneDriveSettingsData>('onedrive');
+        if (stored) {
+          settings = { ...DEFAULT_SETTINGS, ...stored };
+        }
+      }
+    } catch (error) {
+      console.error('[OneDriveSettingsManager] Failed to load settings:', error);
+    }
+
+    this.cachedSettings = settings;
+    return settings;
+  }
+
+  static saveSettings(settings: OneDriveSettingsData): void {
+    try {
+      if (!SecureSettingsRepository.isInitialized()) {
+        throw new Error('SecureSettingsRepository not initialized');
+      }
+      const repository = SecureSettingsRepository.getInstance();
+      repository.save('onedrive', settings);
+      this.cachedSettings = settings;
+      console.log('[OneDriveSettingsManager] Settings saved');
+    } catch (error) {
+      console.error('[OneDriveSettingsManager] Failed to save settings:', error);
+    }
+  }
+
+  static clearCache(): void {
+    this.cachedSettings = null;
+  }
+}

package/src/electron/settings/sharepoint-manager.ts

@@ -0,0 +1,58 @@
+/**
+ * SharePoint Settings Manager
+ *
+ * Stores SharePoint integration settings in encrypted database.
+ */
+
+import { SecureSettingsRepository } from '../database/SecureSettingsRepository';
+import { SharePointSettingsData } from '../../shared/types';
+
+const DEFAULT_SETTINGS: SharePointSettingsData = {
+  enabled: false,
+  timeoutMs: 20000,
+};
+
+export class SharePointSettingsManager {
+  private static cachedSettings: SharePointSettingsData | null = null;
+
+  static loadSettings(): SharePointSettingsData {
+    if (this.cachedSettings) {
+      return this.cachedSettings;
+    }
+
+    let settings: SharePointSettingsData = { ...DEFAULT_SETTINGS };
+
+    try {
+      if (SecureSettingsRepository.isInitialized()) {
+        const repository = SecureSettingsRepository.getInstance();
+        const stored = repository.load<SharePointSettingsData>('sharepoint');
+        if (stored) {
+          settings = { ...DEFAULT_SETTINGS, ...stored };
+        }
+      }
+    } catch (error) {
+      console.error('[SharePointSettingsManager] Failed to load settings:', error);
+    }
+
+    this.cachedSettings = settings;
+    return settings;
+  }
+
+  static saveSettings(settings: SharePointSettingsData): void {
+    try {
+      if (!SecureSettingsRepository.isInitialized()) {
+        throw new Error('SecureSettingsRepository not initialized');
+      }
+      const repository = SecureSettingsRepository.getInstance();
+      repository.save('sharepoint', settings);
+      this.cachedSettings = settings;
+      console.log('[SharePointSettingsManager] Settings saved');
+    } catch (error) {
+      console.error('[SharePointSettingsManager] Failed to save settings:', error);
+    }
+  }
+
+  static clearCache(): void {
+    this.cachedSettings = null;
+  }
+}

package/src/electron/utils/box-api.ts

@@ -0,0 +1,184 @@
+/**
+ * Box API helpers
+ */
+
+import { BoxConnectionTestResult, BoxSettingsData } from '../../shared/types';
+
+export const BOX_API_BASE = 'https://api.box.com/2.0';
+export const BOX_UPLOAD_BASE = 'https://upload.box.com/api/2.0';
+const DEFAULT_TIMEOUT_MS = 20000;
+
+function parseJsonSafe(text: string): any | undefined {
+  const trimmed = text.trim();
+  if (!trimmed) return undefined;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return undefined;
+  }
+}
+
+function formatBoxError(status: number, data: any, fallback?: string): string {
+  const message =
+    data?.message ||
+    data?.error?.message ||
+    data?.error_description ||
+    fallback ||
+    'Box API error';
+  return `Box API error ${status}: ${message}`;
+}
+
+export interface BoxRequestOptions {
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+  path: string;
+  query?: Record<string, string | number | boolean | undefined>;
+  body?: Record<string, any>;
+  timeoutMs?: number;
+}
+
+export interface BoxRequestResult {
+  status: number;
+  data?: any;
+  raw?: string;
+}
+
+export async function boxRequest(
+  settings: BoxSettingsData,
+  options: BoxRequestOptions
+): Promise<BoxRequestResult> {
+  if (!settings.accessToken) {
+    throw new Error('Box access token not configured. Add it in Settings > Integrations > Box.');
+  }
+
+  const params = new URLSearchParams();
+  if (options.query) {
+    for (const [key, value] of Object.entries(options.query)) {
+      if (value === undefined || value === null) continue;
+      params.set(key, String(value));
+    }
+  }
+  const queryString = params.toString();
+  const url = `${BOX_API_BASE}${options.path}${queryString ? `?${queryString}` : ''}`;
+
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${settings.accessToken}`,
+  };
+
+  if (options.method !== 'GET' && options.method !== 'DELETE') {
+    headers['Content-Type'] = 'application/json';
+  }
+
+  const timeoutMs = options.timeoutMs ?? settings.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await fetch(url, {
+      method: options.method,
+      headers,
+      body: options.body ? JSON.stringify(options.body) : undefined,
+      signal: controller.signal,
+    });
+
+    const rawText = typeof response.text === 'function' ? await response.text() : '';
+    const data = rawText ? parseJsonSafe(rawText) : undefined;
+
+    if (!response.ok) {
+      throw new Error(formatBoxError(response.status, data, response.statusText));
+    }
+
+    return {
+      status: response.status,
+      data: data ?? undefined,
+      raw: rawText || undefined,
+    };
+  } catch (error: any) {
+    if (error?.name === 'AbortError') {
+      throw new Error('Box API request timed out');
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export async function boxUploadFile(
+  settings: BoxSettingsData,
+  opts: { fileName: string; parentId: string; data: Uint8Array; timeoutMs?: number }
+): Promise<BoxRequestResult> {
+  if (!settings.accessToken) {
+    throw new Error('Box access token not configured. Add it in Settings > Integrations > Box.');
+  }
+
+  if (typeof FormData === 'undefined') {
+    throw new Error('FormData not available in this environment');
+  }
+
+  const form = new FormData();
+  form.append('attributes', JSON.stringify({ name: opts.fileName, parent: { id: opts.parentId } }));
+  // Create a copy with a regular ArrayBuffer to satisfy BlobPart type requirements
+  const fileData = new Uint8Array(opts.data);
+  form.append('file', new Blob([fileData]), opts.fileName);
+
+  const url = `${BOX_UPLOAD_BASE}/files/content`;
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${settings.accessToken}`,
+  };
+
+  const timeoutMs = opts.timeoutMs ?? settings.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: form,
+      signal: controller.signal,
+    });
+
+    const rawText = typeof response.text === 'function' ? await response.text() : '';
+    const data = rawText ? parseJsonSafe(rawText) : undefined;
+
+    if (!response.ok) {
+      throw new Error(formatBoxError(response.status, data, response.statusText));
+    }
+
+    return {
+      status: response.status,
+      data: data ?? undefined,
+      raw: rawText || undefined,
+    };
+  } catch (error: any) {
+    if (error?.name === 'AbortError') {
+      throw new Error('Box upload request timed out');
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+function extractUserInfo(data: any): { name?: string; userId?: string } {
+  if (!data || typeof data !== 'object') return {};
+  const name = data.name || data.login || undefined;
+  const userId = data.id || data.user_id || undefined;
+  return { name, userId };
+}
+
+export async function testBoxConnection(settings: BoxSettingsData): Promise<BoxConnectionTestResult> {
+  try {
+    const result = await boxRequest(settings, { method: 'GET', path: '/users/me' });
+    const extracted = extractUserInfo(result.data);
+    return {
+      success: true,
+      name: extracted.name,
+      userId: extracted.userId,
+    };
+  } catch (error: any) {
+    return {
+      success: false,
+      error: error?.message || 'Failed to connect to Box',
+    };
+  }
+}

package/src/electron/utils/dropbox-api.ts

@@ -0,0 +1,171 @@
+/**
+ * Dropbox API helpers
+ */
+
+import { DropboxConnectionTestResult, DropboxSettingsData } from '../../shared/types';
+
+export const DROPBOX_API_BASE = 'https://api.dropboxapi.com/2';
+export const DROPBOX_CONTENT_BASE = 'https://content.dropboxapi.com/2';
+const DEFAULT_TIMEOUT_MS = 20000;
+
+function parseJsonSafe(text: string): any | undefined {
+  const trimmed = text.trim();
+  if (!trimmed) return undefined;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return undefined;
+  }
+}
+
+function formatDropboxError(status: number, data: any, fallback?: string): string {
+  const message =
+    data?.error_summary ||
+    data?.error?.summary ||
+    data?.message ||
+    fallback ||
+    'Dropbox API error';
+  return `Dropbox API error ${status}: ${message}`;
+}
+
+export interface DropboxRequestOptions {
+  method: 'POST';
+  path: string;
+  body?: Record<string, any>;
+  timeoutMs?: number;
+}
+
+export interface DropboxRequestResult {
+  status: number;
+  data?: any;
+  raw?: string;
+}
+
+export async function dropboxRequest(
+  settings: DropboxSettingsData,
+  options: DropboxRequestOptions
+): Promise<DropboxRequestResult> {
+  if (!settings.accessToken) {
+    throw new Error('Dropbox access token not configured. Add it in Settings > Integrations > Dropbox.');
+  }
+
+  const url = `${DROPBOX_API_BASE}${options.path}`;
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${settings.accessToken}`,
+    'Content-Type': 'application/json',
+  };
+
+  const timeoutMs = options.timeoutMs ?? settings.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await fetch(url, {
+      method: options.method,
+      headers,
+      body: JSON.stringify(options.body || {}),
+      signal: controller.signal,
+    });
+
+    const rawText = typeof response.text === 'function' ? await response.text() : '';
+    const data = rawText ? parseJsonSafe(rawText) : undefined;
+
+    if (!response.ok) {
+      throw new Error(formatDropboxError(response.status, data, response.statusText));
+    }
+
+    return {
+      status: response.status,
+      data: data ?? undefined,
+      raw: rawText || undefined,
+    };
+  } catch (error: any) {
+    if (error?.name === 'AbortError') {
+      throw new Error('Dropbox API request timed out');
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export async function dropboxContentUpload(
+  settings: DropboxSettingsData,
+  opts: { path: string; data: Uint8Array; timeoutMs?: number }
+): Promise<DropboxRequestResult> {
+  if (!settings.accessToken) {
+    throw new Error('Dropbox access token not configured. Add it in Settings > Integrations > Dropbox.');
+  }
+
+  const url = `${DROPBOX_CONTENT_BASE}/files/upload`;
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${settings.accessToken}`,
+    'Content-Type': 'application/octet-stream',
+    'Dropbox-API-Arg': JSON.stringify({
+      path: opts.path,
+      mode: 'add',
+      autorename: true,
+      mute: false,
+      strict_conflict: false,
+    }),
+  };
+
+  const timeoutMs = opts.timeoutMs ?? settings.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: opts.data,
+      signal: controller.signal,
+    });
+
+    const rawText = typeof response.text === 'function' ? await response.text() : '';
+    const data = rawText ? parseJsonSafe(rawText) : undefined;
+
+    if (!response.ok) {
+      throw new Error(formatDropboxError(response.status, data, response.statusText));
+    }
+
+    return {
+      status: response.status,
+      data: data ?? undefined,
+      raw: rawText || undefined,
+    };
+  } catch (error: any) {
+    if (error?.name === 'AbortError') {
+      throw new Error('Dropbox upload request timed out');
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+function extractAccountInfo(data: any): { name?: string; userId?: string; email?: string } {
+  if (!data || typeof data !== 'object') return {};
+  const name = data?.name?.display_name || data?.name?.abbreviated_name || undefined;
+  const userId = data?.account_id || data?.id || undefined;
+  const email = data?.email || undefined;
+  return { name, userId, email };
+}
+
+export async function testDropboxConnection(settings: DropboxSettingsData): Promise<DropboxConnectionTestResult> {
+  try {
+    const result = await dropboxRequest(settings, { method: 'POST', path: '/users/get_current_account' });
+    const extracted = extractAccountInfo(result.data);
+    return {
+      success: true,
+      name: extracted.name,
+      userId: extracted.userId,
+      email: extracted.email,
+    };
+  } catch (error: any) {
+    return {
+      success: false,
+      error: error?.message || 'Failed to connect to Dropbox',
+    };
+  }
+}

package/src/electron/utils/env-migration.ts

@@ -137,6 +137,28 @@ export async function migrateEnvToSettings(): Promise<MigrationResult> {
       llmChanged = true;
     }
 
+    // Migrate Groq API key
+    if (env.GROQ_API_KEY && !llmSettings.groq?.apiKey) {
+      llmSettings.groq = { ...llmSettings.groq, apiKey: env.GROQ_API_KEY };
+      migratedKeys.push('Groq API Key');
+      llmChanged = true;
+    }
+
+    // Migrate xAI API key
+    if (env.XAI_API_KEY && !llmSettings.xai?.apiKey) {
+      llmSettings.xai = { ...llmSettings.xai, apiKey: env.XAI_API_KEY };
+      migratedKeys.push('xAI API Key');
+      llmChanged = true;
+    }
+
+    // Migrate Kimi API key (Moonshot)
+    const kimiApiKey = env.KIMI_API_KEY || env.MOONSHOT_API_KEY;
+    if (kimiApiKey && !llmSettings.kimi?.apiKey) {
+      llmSettings.kimi = { ...llmSettings.kimi, apiKey: kimiApiKey };
+      migratedKeys.push('Kimi API Key');
+      llmChanged = true;
+    }
+
     // Migrate Ollama settings
     if (env.OLLAMA_BASE_URL && !llmSettings.ollama?.baseUrl) {
       llmSettings.ollama = {

package/src/electron/utils/gmail-api.ts

@@ -0,0 +1,121 @@
+/**
+ * Gmail API helpers
+ */
+
+import { GoogleWorkspaceSettingsData } from '../../shared/types';
+import { getGoogleWorkspaceAccessToken, refreshGoogleWorkspaceAccessToken } from './google-workspace-auth';
+
+export const GMAIL_API_BASE = 'https://gmail.googleapis.com/gmail/v1';
+const DEFAULT_TIMEOUT_MS = 20000;
+
+function parseJsonSafe(text: string): any | undefined {
+  const trimmed = text.trim();
+  if (!trimmed) return undefined;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return undefined;
+  }
+}
+
+function formatGmailError(status: number, data: any, fallback?: string): string {
+  const message =
+    data?.error?.message ||
+    data?.message ||
+    fallback ||
+    'Gmail API error';
+  return `Gmail API error ${status}: ${message}`;
+}
+
+export interface GmailRequestOptions {
+  method: 'GET' | 'POST' | 'PATCH' | 'DELETE';
+  path: string;
+  query?: Record<string, string | number | boolean | string[] | undefined>;
+  body?: any;
+  timeoutMs?: number;
+}
+
+export interface GmailRequestResult {
+  status: number;
+  data?: any;
+  raw?: string;
+}
+
+export async function gmailRequest(
+  settings: GoogleWorkspaceSettingsData,
+  options: GmailRequestOptions
+): Promise<GmailRequestResult> {
+  const params = new URLSearchParams();
+  if (options.query) {
+    for (const [key, value] of Object.entries(options.query)) {
+      if (value === undefined || value === null) continue;
+      if (Array.isArray(value)) {
+        value.forEach((item) => {
+          if (item !== undefined && item !== null) params.append(key, String(item));
+        });
+        continue;
+      }
+      params.set(key, String(value));
+    }
+  }
+  const queryString = params.toString();
+  const url = `${GMAIL_API_BASE}${options.path}${queryString ? `?${queryString}` : ''}`;
+
+  const timeoutMs = options.timeoutMs ?? settings.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+
+  const requestOnce = async (accessToken: string): Promise<GmailRequestResult> => {
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${accessToken}`,
+    };
+
+    if (options.method !== 'GET' && options.method !== 'DELETE') {
+      headers['Content-Type'] = 'application/json';
+    }
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+    try {
+      const response = await fetch(url, {
+        method: options.method,
+        headers,
+        body: options.body ? JSON.stringify(options.body) : undefined,
+        signal: controller.signal,
+      });
+
+      const rawText = typeof response.text === 'function' ? await response.text() : '';
+      const data = rawText ? parseJsonSafe(rawText) : undefined;
+
+      if (!response.ok) {
+        throw Object.assign(new Error(formatGmailError(response.status, data, response.statusText)), {
+          status: response.status,
+          data,
+        });
+      }
+
+      return {
+        status: response.status,
+        data: data ?? undefined,
+        raw: rawText || undefined,
+      };
+    } catch (error: any) {
+      if (error?.name === 'AbortError') {
+        throw new Error('Gmail API request timed out');
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
+  };
+
+  try {
+    const accessToken = await getGoogleWorkspaceAccessToken(settings);
+    return await requestOnce(accessToken);
+  } catch (error: any) {
+    if (error?.status === 401 && settings.refreshToken) {
+      const refreshedToken = await refreshGoogleWorkspaceAccessToken(settings);
+      return await requestOnce(refreshedToken);
+    }
+    throw error;
+  }
+}