@hasna/connectors 1.1.4 → 1.1.5

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

@@ -1,131 +0,0 @@
-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

@@ -1,198 +0,0 @@
-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

@@ -1,312 +0,0 @@
-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);
-  }
-}