@hasna/connectors 0.0.1

package/connectors/connect-gmail/src/api/client.ts

@@ -0,0 +1,131 @@
+import type { OutputFormat } from '../types';
+import { GmailApiError } from '../types';
+import { getValidAccessToken } from '../utils/auth';
+
+const GMAIL_API_BASE = 'https://gmail.googleapis.com/gmail/v1';
+
+export interface RequestOptions {
+  method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+  params?: Record<string, string | number | boolean | undefined>;
+  body?: Record<string, unknown> | unknown[] | string;
+  headers?: Record<string, string>;
+  format?: OutputFormat;
+}
+
+export class GmailClient {
+  private accessToken?: string;
+  private userId: string = 'me'; // Default to authenticated user
+
+  constructor() {}
+
+  setUserId(userId: string): void {
+    this.userId = userId;
+  }
+
+  getUserId(): string {
+    return this.userId;
+  }
+
+  private buildUrl(path: string, params?: Record<string, string | number | boolean | undefined>): string {
+    const url = new URL(`${GMAIL_API_BASE}${path}`);
+
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined && value !== null && value !== '') {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+
+    return url.toString();
+  }
+
+  async request<T>(path: string, options: RequestOptions = {}): Promise<T> {
+    const { method = 'GET', params, body, headers = {} } = options;
+
+    // Get fresh access token (handles refresh automatically)
+    const accessToken = await getValidAccessToken();
+
+    const url = this.buildUrl(path, params);
+
+    const requestHeaders: Record<string, string> = {
+      'Authorization': `Bearer ${accessToken}`,
+      'Accept': 'application/json',
+      ...headers,
+    };
+
+    if (body && ['POST', 'PUT', 'PATCH'].includes(method)) {
+      if (typeof body === 'string') {
+        requestHeaders['Content-Type'] = 'message/rfc822';
+      } else {
+        requestHeaders['Content-Type'] = 'application/json';
+      }
+    }
+
+    const fetchOptions: RequestInit = {
+      method,
+      headers: requestHeaders,
+    };
+
+    if (body && ['POST', 'PUT', 'PATCH'].includes(method)) {
+      fetchOptions.body = typeof body === 'string' ? body : JSON.stringify(body);
+    }
+
+    const response = await fetch(url, fetchOptions);
+
+    // Handle 204 No Content
+    if (response.status === 204) {
+      return {} as T;
+    }
+
+    // Parse response
+    let data: unknown;
+    const contentType = response.headers.get('content-type') || '';
+
+    if (contentType.includes('application/json')) {
+      const text = await response.text();
+      if (text) {
+        try {
+          data = JSON.parse(text);
+        } catch {
+          data = text;
+        }
+      }
+    } else {
+      data = await response.text();
+    }
+
+    // Handle errors
+    if (!response.ok) {
+      const errorData = data as { error?: { message?: string; code?: number; errors?: unknown[] } };
+      const errorMessage = errorData?.error?.message || String(data || response.statusText);
+      throw new GmailApiError(
+        errorMessage,
+        response.status,
+        errorData?.error?.errors as GmailApiError['errors']
+      );
+    }
+
+    return data as T;
+  }
+
+  async get<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
+    return this.request<T>(path, { method: 'GET', params });
+  }
+
+  async post<T>(path: string, body?: Record<string, unknown> | unknown[] | string, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
+    return this.request<T>(path, { method: 'POST', body, params });
+  }
+
+  async put<T>(path: string, body?: Record<string, unknown>, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
+    return this.request<T>(path, { method: 'PUT', body, params });
+  }
+
+  async patch<T>(path: string, body?: Record<string, unknown>, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
+    return this.request<T>(path, { method: 'PATCH', body, params });
+  }
+
+  async delete<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
+    return this.request<T>(path, { method: 'DELETE', params });
+  }
+}

package/connectors/connect-gmail/src/api/drafts.ts

@@ -0,0 +1,198 @@
+import type { GmailClient } from './client';
+import type { GmailMessage, GmailDraft, SendMessageOptions } from '../types';
+import { getFormattedSender, getUserEmail } from '../utils/config';
+import { formatEmailWithName } from '../utils/contacts';
+import { markdownToHtml, wrapInEmailTemplate, looksLikeMarkdown } from '../utils/markdown';
+import { loadSettings, shouldAppendSignature, getSignature } from '../utils/settings';
+
+/**
+ * Encode a string for email headers using RFC 2047 MIME encoded-word syntax
+ */
+function encodeHeaderValue(value: string): string {
+  if (!/[^\x00-\x7F]/.test(value)) {
+    return value;
+  }
+  const encoded = Buffer.from(value, 'utf-8').toString('base64');
+  return `=?UTF-8?B?${encoded}?=`;
+}
+
+/**
+ * Strip HTML tags to create plain text version
+ */
+function htmlToPlainText(html: string): string {
+  return html
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<\/p>/gi, '\n\n')
+    .replace(/<\/div>/gi, '\n')
+    .replace(/<[^>]+>/g, '')
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+export class DraftsApi {
+  private client: GmailClient;
+
+  constructor(client: GmailClient) {
+    this.client = client;
+  }
+
+  /**
+   * List drafts in the user's mailbox
+   */
+  async list(maxResults: number = 10): Promise<{ drafts: GmailDraft[] }> {
+    return this.client.get<{ drafts: GmailDraft[] }>(
+      `/users/${this.client.getUserId()}/drafts`,
+      { maxResults }
+    );
+  }
+
+  /**
+   * Get a specific draft by ID
+   */
+  async get(draftId: string): Promise<GmailDraft> {
+    return this.client.get<GmailDraft>(
+      `/users/${this.client.getUserId()}/drafts/${draftId}`
+    );
+  }
+
+  /**
+   * Create a new draft
+   */
+  async create(options: SendMessageOptions): Promise<GmailDraft> {
+    const message = this.buildRawMessage(options);
+    const encodedMessage = Buffer.from(message).toString('base64url');
+
+    return this.client.post<GmailDraft>(
+      `/users/${this.client.getUserId()}/drafts`,
+      {
+        message: {
+          raw: encodedMessage,
+        },
+      }
+    );
+  }
+
+  /**
+   * Update an existing draft
+   */
+  async update(draftId: string, options: SendMessageOptions): Promise<GmailDraft> {
+    const message = this.buildRawMessage(options);
+    const encodedMessage = Buffer.from(message).toString('base64url');
+
+    return this.client.put<GmailDraft>(
+      `/users/${this.client.getUserId()}/drafts/${draftId}`,
+      {
+        message: {
+          raw: encodedMessage,
+        },
+      }
+    );
+  }
+
+  /**
+   * Delete a draft
+   */
+  async delete(draftId: string): Promise<void> {
+    await this.client.delete(
+      `/users/${this.client.getUserId()}/drafts/${draftId}`
+    );
+  }
+
+  /**
+   * Send a draft
+   */
+  async send(draftId: string): Promise<GmailMessage> {
+    return this.client.post<GmailMessage>(
+      `/users/${this.client.getUserId()}/drafts/send`,
+      { id: draftId }
+    );
+  }
+
+  /**
+   * Build RFC 2822 formatted message with signature, markdown support
+   */
+  private buildRawMessage(options: SendMessageOptions): string {
+    const settings = loadSettings();
+
+    // Format addresses with contact names
+    const formatAddresses = (addresses: string | string[]): string => {
+      const addrs = Array.isArray(addresses) ? addresses : [addresses];
+      return addrs.map(addr => {
+        if (addr.includes('<') && addr.includes('>')) {
+          return addr;
+        }
+        return formatEmailWithName(addr);
+      }).join(', ');
+    };
+
+    const to = formatAddresses(options.to);
+    const cc = options.cc ? formatAddresses(options.cc) : '';
+    const bcc = options.bcc ? formatAddresses(options.bcc) : '';
+
+    // Process body: markdown conversion and signature
+    let body = options.body;
+    let isHtml = options.isHtml || false;
+
+    // Auto-detect and convert markdown if enabled
+    if (settings.markdownEnabled && !isHtml && looksLikeMarkdown(body)) {
+      body = markdownToHtml(body);
+      isHtml = true;
+    }
+
+    // Append signature (drafts are new emails, not replies)
+    if (shouldAppendSignature(false)) {
+      const signature = getSignature();
+      if (signature) {
+        // Gmail signatures are HTML, so convert body to HTML if needed
+        if (!isHtml) {
+          // Convert plain text to simple HTML
+          body = body.replace(/\n/g, '<br>');
+          isHtml = true;
+        }
+        body += `<br><br>${signature}`;
+      }
+    }
+
+    // Get formatted sender with display name
+    let from: string;
+    try {
+      from = getFormattedSender();
+    } catch {
+      from = getUserEmail() || '';
+    }
+
+    let message = '';
+    message += `From: ${from}\r\n`;
+    message += `To: ${to}\r\n`;
+    if (cc) message += `Cc: ${cc}\r\n`;
+    if (bcc) message += `Bcc: ${bcc}\r\n`;
+    message += `Subject: ${encodeHeaderValue(options.subject)}\r\n`;
+    message += `MIME-Version: 1.0\r\n`;
+
+    if (isHtml) {
+      // Send multipart/alternative with both plain text and HTML
+      const boundary = `boundary_${Date.now()}`;
+      const htmlBody = wrapInEmailTemplate(body);
+      const plainBody = htmlToPlainText(body);
+
+      message += `Content-Type: multipart/alternative; boundary="${boundary}"\r\n\r\n`;
+      message += `--${boundary}\r\n`;
+      message += `Content-Type: text/plain; charset="UTF-8"\r\n\r\n`;
+      message += `${plainBody}\r\n`;
+      message += `--${boundary}\r\n`;
+      message += `Content-Type: text/html; charset="UTF-8"\r\n\r\n`;
+      message += `${htmlBody}\r\n`;
+      message += `--${boundary}--`;
+    } else {
+      message += `Content-Type: text/plain; charset="UTF-8"\r\n\r\n`;
+      message += body;
+    }
+
+    return message;
+  }
+}

package/connectors/connect-gmail/src/api/export.ts

@@ -0,0 +1,312 @@
+import { writeFileSync, mkdirSync, existsSync, appendFileSync } from 'fs';
+import { join, dirname } from 'path';
+import type { GmailClient } from './client';
+import type { GmailMessage, MessageListResponse } from '../types';
+import { ensureExportsDir } from '../utils/config';
+
+export interface ExportOptions {
+  query?: string;
+  labelIds?: string[];
+  maxResults?: number;
+  outputDir?: string;
+  filename?: string;
+  format?: 'eml' | 'mbox';
+  includeAttachments?: boolean;
+}
+
+export interface ExportResult {
+  messageCount: number;
+  filePath: string;
+  format: string;
+}
+
+export class ExportApi {
+  constructor(private readonly client: GmailClient) {}
+
+  // ============================================
+  // Main Export Methods
+  // ============================================
+
+  /**
+   * Export messages to EML or MBOX format
+   */
+  async exportMessages(options: ExportOptions = {}): Promise<ExportResult> {
+    const format = options.format || 'eml';
+    const messages = await this.getMessages(options);
+
+    if (messages.length === 0) {
+      const outputDir = options.outputDir || ensureExportsDir();
+      const filename = options.filename || `emails_${new Date().toISOString().split('T')[0]}.${format === 'mbox' ? 'mbox' : 'eml'}`;
+      const filePath = join(outputDir, filename);
+      writeFileSync(filePath, '', 'utf-8');
+      return {
+        messageCount: 0,
+        filePath,
+        format,
+      };
+    }
+
+    if (format === 'mbox') {
+      return this.exportToMbox(messages, options);
+    } else {
+      return this.exportToEml(messages, options);
+    }
+  }
+
+  /**
+   * Export messages from a specific label
+   */
+  async exportLabel(labelId: string, options: Omit<ExportOptions, 'labelIds'> = {}): Promise<ExportResult> {
+    return this.exportMessages({
+      ...options,
+      labelIds: [labelId],
+    });
+  }
+
+  /**
+   * Export inbox messages
+   */
+  async exportInbox(options: Omit<ExportOptions, 'labelIds'> = {}): Promise<ExportResult> {
+    return this.exportLabel('INBOX', options);
+  }
+
+  /**
+   * Export sent messages
+   */
+  async exportSent(options: Omit<ExportOptions, 'labelIds'> = {}): Promise<ExportResult> {
+    return this.exportLabel('SENT', options);
+  }
+
+  /**
+   * Export starred messages
+   */
+  async exportStarred(options: Omit<ExportOptions, 'labelIds'> = {}): Promise<ExportResult> {
+    return this.exportLabel('STARRED', options);
+  }
+
+  /**
+   * Export a single message
+   */
+  async exportMessage(messageId: string, options: { outputDir?: string; filename?: string } = {}): Promise<ExportResult> {
+    const message = await this.client.get<GmailMessage>(
+      `/users/${this.client.getUserId()}/messages/${messageId}`,
+      { format: 'raw' }
+    );
+
+    const outputDir = options.outputDir || ensureExportsDir();
+    const filename = options.filename || `message_${messageId}.eml`;
+    const filePath = join(outputDir, filename);
+
+    if (!existsSync(dirname(filePath))) {
+      mkdirSync(dirname(filePath), { recursive: true });
+    }
+
+    // Decode the raw message from base64url
+    const rawContent = this.decodeBase64Url(message.raw || '');
+    writeFileSync(filePath, rawContent, 'utf-8');
+
+    return {
+      messageCount: 1,
+      filePath,
+      format: 'eml',
+    };
+  }
+
+  /**
+   * Export a thread (all messages in a conversation)
+   */
+  async exportThread(threadId: string, options: Omit<ExportOptions, 'query' | 'labelIds'> = {}): Promise<ExportResult> {
+    const thread = await this.client.get<{ messages: Array<{ id: string }> }>(
+      `/users/${this.client.getUserId()}/threads/${threadId}`,
+      { format: 'minimal' }
+    );
+
+    const messageIds = thread.messages.map(m => m.id);
+    const messages: GmailMessage[] = [];
+
+    for (const id of messageIds) {
+      const message = await this.client.get<GmailMessage>(
+        `/users/${this.client.getUserId()}/messages/${id}`,
+        { format: 'raw' }
+      );
+      messages.push(message);
+    }
+
+    const format = options.format || 'mbox';
+    if (format === 'mbox') {
+      return this.exportToMbox(messages, {
+        ...options,
+        filename: options.filename || `thread_${threadId}.mbox`,
+      });
+    } else {
+      return this.exportToEml(messages, {
+        ...options,
+        filename: options.filename || `thread_${threadId}`,
+      });
+    }
+  }
+
+  // ============================================
+  // Export Formats
+  // ============================================
+
+  private async exportToEml(messages: GmailMessage[], options: ExportOptions): Promise<ExportResult> {
+    const outputDir = options.outputDir || ensureExportsDir();
+    const timestamp = new Date().toISOString().split('T')[0];
+    const exportDir = join(outputDir, options.filename || `emails_${timestamp}`);
+
+    if (!existsSync(exportDir)) {
+      mkdirSync(exportDir, { recursive: true });
+    }
+
+    for (let i = 0; i < messages.length; i++) {
+      const message = messages[i];
+      const rawContent = this.decodeBase64Url(message.raw || '');
+
+      // Get subject for filename
+      const subjectMatch = rawContent.match(/^Subject:\s*(.+)$/m);
+      let subject = subjectMatch ? subjectMatch[1].trim() : `message_${i + 1}`;
+      subject = this.sanitizeFilename(subject).slice(0, 50);
+
+      const filename = `${i + 1}_${message.id}_${subject}.eml`;
+      const filePath = join(exportDir, filename);
+
+      writeFileSync(filePath, rawContent, 'utf-8');
+    }
+
+    return {
+      messageCount: messages.length,
+      filePath: exportDir,
+      format: 'eml',
+    };
+  }
+
+  private async exportToMbox(messages: GmailMessage[], options: ExportOptions): Promise<ExportResult> {
+    const outputDir = options.outputDir || ensureExportsDir();
+    const filename = options.filename || `emails_${new Date().toISOString().split('T')[0]}.mbox`;
+    const filePath = join(outputDir, filename);
+
+    if (!existsSync(dirname(filePath))) {
+      mkdirSync(dirname(filePath), { recursive: true });
+    }
+
+    // Clear or create the file
+    writeFileSync(filePath, '', 'utf-8');
+
+    for (const message of messages) {
+      const rawContent = this.decodeBase64Url(message.raw || '');
+
+      // Get the From header for the mbox "From " line
+      const fromMatch = rawContent.match(/^From:\s*(.+)$/m);
+      let fromAddr = 'unknown@unknown.com';
+      if (fromMatch) {
+        const emailMatch = fromMatch[1].match(/<([^>]+)>/) || fromMatch[1].match(/([^\s<>]+@[^\s<>]+)/);
+        if (emailMatch) {
+          fromAddr = emailMatch[1];
+        }
+      }
+
+      // Get date for the mbox "From " line
+      const dateMatch = rawContent.match(/^Date:\s*(.+)$/m);
+      let mboxDate = new Date().toUTCString();
+      if (dateMatch) {
+        try {
+          const parsed = new Date(dateMatch[1]);
+          if (!isNaN(parsed.getTime())) {
+            // Convert to mbox format: "Mon Jan 01 12:00:00 2024"
+            mboxDate = parsed.toUTCString().replace(/,/g, '').replace(/ GMT$/, '');
+          }
+        } catch {
+          // Keep default date
+        }
+      }
+
+      // Write mbox format: "From <email> <date>\n<raw message>\n"
+      const mboxLine = `From ${fromAddr} ${mboxDate}\n`;
+      appendFileSync(filePath, mboxLine, 'utf-8');
+
+      // Escape any "From " lines at the start of message body lines
+      const escapedContent = rawContent.replace(/^From /gm, '>From ');
+      appendFileSync(filePath, escapedContent, 'utf-8');
+
+      // Ensure message ends with newline
+      if (!rawContent.endsWith('\n')) {
+        appendFileSync(filePath, '\n', 'utf-8');
+      }
+      appendFileSync(filePath, '\n', 'utf-8');
+    }
+
+    return {
+      messageCount: messages.length,
+      filePath,
+      format: 'mbox',
+    };
+  }
+
+  // ============================================
+  // Helper Methods
+  // ============================================
+
+  private async getMessages(options: ExportOptions): Promise<GmailMessage[]> {
+    const messages: GmailMessage[] = [];
+    let pageToken: string | undefined;
+    const maxResults = options.maxResults || 1000;
+    let fetched = 0;
+
+    do {
+      const params: Record<string, string | number | boolean | undefined> = {
+        maxResults: Math.min(100, maxResults - fetched),
+        pageToken,
+        q: options.query,
+        includeSpamTrash: false,
+      };
+
+      if (options.labelIds && options.labelIds.length > 0) {
+        params.labelIds = options.labelIds.join(',');
+      }
+
+      const response = await this.client.get<MessageListResponse>(
+        `/users/${this.client.getUserId()}/messages`,
+        params
+      );
+
+      if (!response.messages || response.messages.length === 0) {
+        break;
+      }
+
+      // Fetch full raw content for each message
+      for (const msg of response.messages) {
+        if (fetched >= maxResults) break;
+
+        const fullMessage = await this.client.get<GmailMessage>(
+          `/users/${this.client.getUserId()}/messages/${msg.id}`,
+          { format: 'raw' }
+        );
+        messages.push(fullMessage);
+        fetched++;
+      }
+
+      pageToken = response.nextPageToken;
+    } while (pageToken && fetched < maxResults);
+
+    return messages;
+  }
+
+  private decodeBase64Url(encoded: string): string {
+    // Convert base64url to base64
+    let base64 = encoded.replace(/-/g, '+').replace(/_/g, '/');
+    // Add padding if needed
+    while (base64.length % 4) {
+      base64 += '=';
+    }
+    return Buffer.from(base64, 'base64').toString('utf-8');
+  }
+
+  private sanitizeFilename(name: string): string {
+    return name
+      .replace(/[<>:"/\\|?*\x00-\x1F]/g, '')
+      .replace(/\s+/g, '_')
+      .replace(/^\.+/, '')
+      .slice(0, 200);
+  }
+}