cowork-os 0.3.21

package/src/electron/agent/search/brave-provider.ts

@@ -0,0 +1,141 @@
+import {
+  SearchProvider,
+  SearchProviderConfig,
+  SearchQuery,
+  SearchResponse,
+  SearchResult,
+  SearchType,
+} from './types';
+
+/**
+ * Brave Search API provider
+ * https://brave.com/search/api/
+ */
+export class BraveProvider implements SearchProvider {
+  readonly type = 'brave' as const;
+  readonly supportedSearchTypes: SearchType[] = ['web', 'news', 'images'];
+
+  private apiKey: string;
+  private baseUrl = 'https://api.search.brave.com/res/v1';
+
+  constructor(config: SearchProviderConfig) {
+    const apiKey = config.braveApiKey;
+    if (!apiKey) {
+      throw new Error(
+        'Brave API key is required. Configure it in Settings or get one from https://brave.com/search/api/'
+      );
+    }
+    this.apiKey = apiKey;
+  }
+
+  async search(query: SearchQuery): Promise<SearchResponse> {
+    const searchType = query.searchType || 'web';
+
+    if (!this.supportedSearchTypes.includes(searchType)) {
+      throw new Error(`Brave does not support ${searchType} search`);
+    }
+
+    const endpoint = this.getEndpoint(searchType);
+    const params = new URLSearchParams({
+      q: query.query,
+      count: String(query.maxResults || 10),
+      ...(query.region && { country: query.region }),
+      ...(query.language && { search_lang: query.language }),
+      ...(query.safeSearch !== undefined && {
+        safesearch: query.safeSearch ? 'strict' : 'off',
+      }),
+      ...(query.dateRange && { freshness: this.mapDateRange(query.dateRange) }),
+    });
+
+    const response = await fetch(`${this.baseUrl}/${endpoint}?${params}`, {
+      headers: {
+        Accept: 'application/json',
+        'X-Subscription-Token': this.apiKey,
+      },
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Brave API error: ${response.status} - ${error}`);
+    }
+
+    const data = await response.json();
+
+    return {
+      results: this.mapResults(data, searchType),
+      query: query.query,
+      searchType,
+      provider: 'brave',
+    };
+  }
+
+  async testConnection(): Promise<{ success: boolean; error?: string }> {
+    try {
+      await this.search({ query: 'test', maxResults: 1 });
+      return { success: true };
+    } catch (error: any) {
+      return {
+        success: false,
+        error: error.message || 'Failed to connect to Brave Search API',
+      };
+    }
+  }
+
+  private getEndpoint(searchType: SearchType): string {
+    switch (searchType) {
+      case 'news':
+        return 'news/search';
+      case 'images':
+        return 'images/search';
+      default:
+        return 'web/search';
+    }
+  }
+
+  private mapDateRange(range: string): string {
+    switch (range) {
+      case 'day':
+        return 'pd'; // past day
+      case 'week':
+        return 'pw'; // past week
+      case 'month':
+        return 'pm'; // past month
+      case 'year':
+        return 'py'; // past year
+      default:
+        return 'pw';
+    }
+  }
+
+  private mapResults(data: any, searchType: SearchType): SearchResult[] {
+    if (searchType === 'images') {
+      return (data.results || []).map((r: any) => ({
+        title: r.title || '',
+        url: r.url || r.page_url || '',
+        snippet: r.description || '',
+        thumbnailUrl: r.thumbnail?.src,
+        imageUrl: r.properties?.url || r.url,
+        width: r.properties?.width,
+        height: r.properties?.height,
+      }));
+    }
+
+    if (searchType === 'news') {
+      return (data.results || []).map((r: any) => ({
+        title: r.title || '',
+        url: r.url || '',
+        snippet: r.description || '',
+        publishedDate: r.age,
+        source: r.meta_url?.hostname,
+      }));
+    }
+
+    // Web results
+    return (data.web?.results || []).map((r: any) => ({
+      title: r.title || '',
+      url: r.url || '',
+      snippet: r.description || '',
+      source: r.meta_url?.hostname,
+    }));
+  }
+}

package/src/electron/agent/search/google-provider.ts

@@ -0,0 +1,131 @@
+import {
+  SearchProvider,
+  SearchProviderConfig,
+  SearchQuery,
+  SearchResponse,
+  SearchResult,
+  SearchType,
+} from './types';
+
+/**
+ * Google Custom Search API provider
+ * https://developers.google.com/custom-search/v1/introduction
+ */
+export class GoogleProvider implements SearchProvider {
+  readonly type = 'google' as const;
+  readonly supportedSearchTypes: SearchType[] = ['web', 'images'];
+
+  private apiKey: string;
+  private searchEngineId: string;
+  private baseUrl = 'https://www.googleapis.com/customsearch/v1';
+
+  constructor(config: SearchProviderConfig) {
+    const apiKey = config.googleApiKey;
+    const searchEngineId = config.googleSearchEngineId;
+
+    if (!apiKey) {
+      throw new Error(
+        'Google API key is required. Configure it in Settings or get one from https://console.cloud.google.com/'
+      );
+    }
+    if (!searchEngineId) {
+      throw new Error(
+        'Google Search Engine ID is required. Configure it in Settings or create one at https://programmablesearchengine.google.com/'
+      );
+    }
+
+    this.apiKey = apiKey;
+    this.searchEngineId = searchEngineId;
+  }
+
+  async search(query: SearchQuery): Promise<SearchResponse> {
+    const searchType = query.searchType || 'web';
+
+    if (!this.supportedSearchTypes.includes(searchType)) {
+      throw new Error(
+        `Google Custom Search does not support ${searchType} search. Use 'web' or 'images'.`
+      );
+    }
+
+    const params = new URLSearchParams({
+      key: this.apiKey,
+      cx: this.searchEngineId,
+      q: query.query,
+      num: String(Math.min(query.maxResults || 10, 10)), // Google CSE max is 10
+      ...(query.region && { gl: query.region }),
+      ...(query.language && { lr: `lang_${query.language}` }),
+      ...(query.safeSearch !== undefined && {
+        safe: query.safeSearch ? 'active' : 'off',
+      }),
+      ...(searchType === 'images' && { searchType: 'image' }),
+      ...(query.dateRange && { dateRestrict: this.mapDateRange(query.dateRange) }),
+    });
+
+    const response = await fetch(`${this.baseUrl}?${params}`);
+
+    if (!response.ok) {
+      const error = await response.json() as { error?: { message?: string } };
+      throw new Error(
+        `Google CSE error: ${response.status} - ${error.error?.message || 'Unknown error'}`
+      );
+    }
+
+    const data = await response.json() as {
+      items?: any[];
+      searchInformation?: { totalResults?: string };
+    };
+
+    return {
+      results: this.mapResults(data.items || [], searchType),
+      query: query.query,
+      searchType,
+      totalResults: data.searchInformation?.totalResults
+        ? parseInt(data.searchInformation.totalResults)
+        : undefined,
+      provider: 'google',
+    };
+  }
+
+  async testConnection(): Promise<{ success: boolean; error?: string }> {
+    try {
+      await this.search({ query: 'test', maxResults: 1 });
+      return { success: true };
+    } catch (error: any) {
+      return {
+        success: false,
+        error: error.message || 'Failed to connect to Google Custom Search',
+      };
+    }
+  }
+
+  private mapDateRange(range: string): string {
+    switch (range) {
+      case 'day':
+        return 'd1';
+      case 'week':
+        return 'w1';
+      case 'month':
+        return 'm1';
+      case 'year':
+        return 'y1';
+      default:
+        return 'w1';
+    }
+  }
+
+  private mapResults(items: any[], searchType: SearchType): SearchResult[] {
+    return items.map((item) => ({
+      title: item.title || '',
+      url: item.link || '',
+      snippet: item.snippet || '',
+      // Image-specific fields
+      ...(searchType === 'images' && {
+        thumbnailUrl: item.image?.thumbnailLink,
+        imageUrl: item.link,
+        width: item.image?.width,
+        height: item.image?.height,
+      }),
+      source: item.displayLink,
+    }));
+  }
+}

package/src/electron/agent/search/index.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export { TavilyProvider } from './tavily-provider';
+export { BraveProvider } from './brave-provider';
+export { SerpApiProvider } from './serpapi-provider';
+export { GoogleProvider } from './google-provider';
+export { SearchProviderFactory, SearchSettings } from './provider-factory';