inboxd 1.0.11 → 1.0.12

package/src/gmail-monitor.js

@@ -286,6 +286,359 @@ function groupEmailsBySender(emails) {
   return { groups: groupArray, totalCount: emails.length };
 }
 
+/**
+ * Decodes base64url encoded content
+ * @param {string} str - Base64url encoded string
+ * @returns {string} Decoded UTF-8 string
+ */
+function decodeBase64Url(str) {
+  if (!str) return '';
+  return Buffer.from(str, 'base64url').toString('utf8');
+}
+
+/**
+ * Extracts body content from a Gmail message payload
+ * Handles multipart messages recursively
+ * @param {Object} payload - Gmail message payload
+ * @param {Object} options - { preferHtml: boolean } - prefer HTML for link extraction
+ * @returns {{type: string, content: string}} Body content with mime type
+ */
+function extractBody(payload, options = {}) {
+  const { preferHtml = false } = options;
+
+  // Simple case: body data directly in payload
+  if (payload.body && payload.body.data) {
+    return {
+      type: payload.mimeType,
+      content: decodeBase64Url(payload.body.data)
+    };
+  }
+
+  if (!payload.parts) {
+    return { type: 'text/plain', content: '' };
+  }
+
+  // Determine preference order based on options
+  const mimeOrder = preferHtml
+    ? ['text/html', 'text/plain']
+    : ['text/plain', 'text/html'];
+
+  for (const mimeType of mimeOrder) {
+    const part = payload.parts.find(p => p.mimeType === mimeType);
+    if (part && part.body && part.body.data) {
+      return {
+        type: mimeType,
+        content: decodeBase64Url(part.body.data)
+      };
+    }
+  }
+
+  // Recursive check for nested multipart (e.g., multipart/mixed containing multipart/alternative)
+  for (const part of payload.parts) {
+    if (part.parts) {
+      const found = extractBody(part, options);
+      if (found.content) {
+        return found;
+      }
+    }
+  }
+
+  return { type: 'text/plain', content: '' };
+}
+
+/**
+ * Validates URL scheme - filters out non-http(s) schemes
+ * @param {string} url - URL to validate
+ * @returns {boolean} True if URL should be included
+ */
+function isValidUrl(url) {
+  if (!url) return false;
+  const lowerUrl = url.toLowerCase().trim();
+  // Only allow http and https
+  return lowerUrl.startsWith('http://') || lowerUrl.startsWith('https://');
+}
+
+/**
+ * Extracts links from email body content
+ * @param {string} body - Email body content
+ * @param {string} mimeType - 'text/html' or 'text/plain'
+ * @returns {Array<{url: string, text: string|null}>} Extracted links
+ */
+function extractLinks(body, mimeType) {
+  if (!body) return [];
+
+  const links = [];
+  const seenUrls = new Set();
+
+  // For HTML, extract from anchor tags first (captures link text)
+  if (mimeType === 'text/html') {
+    // Match <a href="URL">Text</a> - handles attributes in any order
+    const hrefRegex = /<a\s+[^>]*href=["']([^"']+)["'][^>]*>([^<]*)<\/a>/gi;
+    let match;
+    while ((match = hrefRegex.exec(body)) !== null) {
+      const url = decodeHtmlEntities(match[1].trim());
+      const text = match[2].trim() || null;
+      if (!seenUrls.has(url) && isValidUrl(url)) {
+        seenUrls.add(url);
+        links.push({ url, text });
+      }
+    }
+  }
+
+  // Also extract plain URLs (works for both HTML and plain text)
+  // This catches URLs not in anchor tags
+  const urlRegex = /https?:\/\/[^\s<>"']+/gi;
+  let urlMatch;
+  while ((urlMatch = urlRegex.exec(body)) !== null) {
+    // Clean trailing punctuation that's likely not part of the URL
+    let url = urlMatch[0].replace(/[.,;:!?)>\]]+$/, '');
+    // Also handle HTML entity at end
+    url = url.replace(/&[a-z]+;?$/i, '');
+    // Decode HTML entities for consistency (important for HTML content)
+    url = decodeHtmlEntities(url);
+    if (!seenUrls.has(url) && isValidUrl(url)) {
+      seenUrls.add(url);
+      links.push({ url, text: null });
+    }
+  }
+
+  return links;
+}
+
+/**
+ * Decodes common HTML entities in URLs
+ * @param {string} str - String potentially containing HTML entities
+ * @returns {string} Decoded string
+ */
+function decodeHtmlEntities(str) {
+  if (!str) return '';
+  return str
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'");
+}
+
+/**
+ * Gets full email content by ID
+ * @param {string} account - Account name
+ * @param {string} messageId - Message ID
+ * @param {Object} options - { preferHtml: boolean } - prefer HTML for link extraction
+ * @returns {Object|null} Email object with body or null if not found
+ */
+async function getEmailContent(account, messageId, options = {}) {
+  try {
+    const gmail = await getGmailClient(account);
+    const detail = await withRetry(() => gmail.users.messages.get({
+      userId: 'me',
+      id: messageId,
+      format: 'full',
+    }));
+
+    const headers = detail.data.payload.headers;
+    const getHeader = (name) => {
+      const header = headers.find((h) => h.name.toLowerCase() === name.toLowerCase());
+      return header ? header.value : '';
+    };
+
+    const bodyData = extractBody(detail.data.payload, options);
+
+    return {
+      id: messageId,
+      threadId: detail.data.threadId,
+      labelIds: detail.data.labelIds || [],
+      account,
+      from: getHeader('From'),
+      to: getHeader('To'),
+      subject: getHeader('Subject'),
+      date: getHeader('Date'),
+      snippet: detail.data.snippet,
+      body: bodyData.content,
+      mimeType: bodyData.type
+    };
+  } catch (error) {
+    console.error(`Error fetching email content ${messageId}:`, error.message);
+    return null;
+  }
+}
+
+/**
+ * Searches for emails using Gmail query syntax
+ * @param {string} account - Account name
+ * @param {string} query - Gmail search query (e.g. "is:unread from:google")
+ * @param {number} maxResults - Max results to return
+ * @returns {Array} List of email metadata objects
+ */
+async function searchEmails(account, query, maxResults = 20) {
+  try {
+    const gmail = await getGmailClient(account);
+    const res = await withRetry(() => gmail.users.messages.list({
+      userId: 'me',
+      q: query,
+      maxResults,
+    }));
+
+    const messages = res.data.messages;
+    if (!messages || messages.length === 0) {
+      return [];
+    }
+
+    const emailPromises = messages.map(async (msg) => {
+      try {
+        const detail = await withRetry(() => gmail.users.messages.get({
+          userId: 'me',
+          id: msg.id,
+          format: 'metadata',
+          metadataHeaders: ['From', 'Subject', 'Date'],
+        }));
+
+        const headers = detail.data.payload.headers;
+        const getHeader = (name) => {
+          const header = headers.find((h) => h.name.toLowerCase() === name.toLowerCase());
+          return header ? header.value : '';
+        };
+
+        return {
+          id: msg.id,
+          threadId: detail.data.threadId,
+          labelIds: detail.data.labelIds || [],
+          account,
+          from: getHeader('From'),
+          subject: getHeader('Subject'),
+          snippet: detail.data.snippet,
+          date: getHeader('Date'),
+        };
+      } catch (_err) {
+        return null;
+      }
+    });
+
+    const results = await Promise.all(emailPromises);
+    return results.filter((email) => email !== null);
+  } catch (error) {
+    console.error(`Error searching emails for ${account}:`, error.message);
+    return [];
+  }
+}
+
+/**
+ * Composes a raw RFC 2822 email message
+ * @param {Object} options - { to, subject, body, inReplyTo?, references? }
+ * @returns {string} Base64url encoded message
+ */
+function composeMessage({ to, subject, body, inReplyTo, references }) {
+  const messageParts = [
+    `To: ${to}`,
+    `Subject: ${subject}`,
+  ];
+
+  if (inReplyTo) {
+    messageParts.push(`In-Reply-To: ${inReplyTo}`);
+  }
+  if (references) {
+    messageParts.push(`References: ${references}`);
+  }
+
+  messageParts.push(
+    'Content-Type: text/plain; charset="UTF-8"',
+    'MIME-Version: 1.0',
+    '',
+    body
+  );
+
+  return Buffer.from(messageParts.join('\n')).toString('base64url');
+}
+
+/**
+ * Sends an email
+ * @param {string} account - Account name
+ * @param {Object} options - { to, subject, body }
+ * @returns {Object} Result object with success, id, threadId, or error
+ */
+async function sendEmail(account, { to, subject, body }) {
+  try {
+    const gmail = await getGmailClient(account);
+    const encodedMessage = composeMessage({ to, subject, body });
+
+    const res = await withRetry(() => gmail.users.messages.send({
+      userId: 'me',
+      requestBody: {
+        raw: encodedMessage
+      }
+    }));
+
+    return { success: true, id: res.data.id, threadId: res.data.threadId };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Reply to an email
+ * @param {string} account - Account name
+ * @param {string} messageId - ID of the message to reply to
+ * @param {string} body - Reply content
+ * @returns {Object} Result object with success, id, threadId, or error
+ */
+async function replyToEmail(account, messageId, body) {
+  try {
+    const gmail = await getGmailClient(account);
+
+    // Get original message headers
+    const original = await withRetry(() => gmail.users.messages.get({
+      userId: 'me',
+      id: messageId,
+      format: 'metadata',
+      metadataHeaders: ['Subject', 'Message-ID', 'References', 'Reply-To', 'From']
+    }));
+
+    const headers = original.data.payload.headers;
+    const getHeader = (name) => {
+      const header = headers.find(h => h.name.toLowerCase() === name.toLowerCase());
+      return header ? header.value : '';
+    };
+
+    const originalSubject = getHeader('Subject');
+    const originalMessageId = getHeader('Message-ID');
+    const originalReferences = getHeader('References');
+    // Prefer Reply-To header, fallback to From
+    const replyTo = getHeader('Reply-To');
+    const originalFrom = getHeader('From');
+    const to = replyTo || originalFrom;
+
+    // Add Re: prefix if not present
+    const subject = originalSubject.toLowerCase().startsWith('re:')
+      ? originalSubject
+      : `Re: ${originalSubject}`;
+
+    // Build references chain
+    const references = originalReferences
+      ? `${originalReferences} ${originalMessageId}`
+      : originalMessageId;
+
+    const encodedMessage = composeMessage({
+      to,
+      subject,
+      body,
+      inReplyTo: originalMessageId,
+      references
+    });
+
+    const res = await withRetry(() => gmail.users.messages.send({
+      userId: 'me',
+      requestBody: {
+        raw: encodedMessage,
+        threadId: original.data.threadId
+      }
+    }));
+
+    return { success: true, id: res.data.id, threadId: res.data.threadId };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
 module.exports = {
   getUnreadEmails,
   getEmailCount,
@@ -296,4 +649,15 @@ module.exports = {
   archiveEmails,
   extractSenderDomain,
   groupEmailsBySender,
+  getEmailContent,
+  searchEmails,
+  sendEmail,
+  replyToEmail,
+  extractLinks,
+  // Exposed for testing
+  extractBody,
+  decodeBase64Url,
+  composeMessage,
+  isValidUrl,
+  decodeHtmlEntities,
 };

package/src/sent-log.js

@@ -0,0 +1,87 @@
+const fs = require('fs');
+const path = require('path');
+const { TOKEN_DIR } = require('./gmail-auth');
+const { atomicWriteJsonSync } = require('./utils');
+
+const LOG_DIR = TOKEN_DIR;
+const LOG_FILE = path.join(LOG_DIR, 'sent-log.json');
+
+/**
+ * Ensures the log directory exists
+ */
+function ensureLogDir() {
+  if (!fs.existsSync(LOG_DIR)) {
+    fs.mkdirSync(LOG_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Reads the current sent log
+ * @returns {Array} Array of sent email entries
+ */
+function readSentLog() {
+  ensureLogDir();
+  if (!fs.existsSync(LOG_FILE)) {
+    return [];
+  }
+  try {
+    const content = fs.readFileSync(LOG_FILE, 'utf8');
+    return JSON.parse(content);
+  } catch (_err) {
+    return [];
+  }
+}
+
+/**
+ * Logs a sent email to the sent log
+ * @param {Object} entry - { account, to, subject, body, id, threadId, replyToId? }
+ */
+function logSentEmail(entry) {
+  ensureLogDir();
+  const log = readSentLog();
+  const timestamp = new Date().toISOString();
+
+  log.push({
+    sentAt: timestamp,
+    account: entry.account,
+    id: entry.id,
+    threadId: entry.threadId,
+    to: entry.to,
+    subject: entry.subject,
+    bodyPreview: entry.body.substring(0, 200),
+    replyToId: entry.replyToId || null,
+  });
+
+  atomicWriteJsonSync(LOG_FILE, log);
+}
+
+/**
+ * Gets recent sent emails from the log
+ * @param {number} days - Number of days to look back (default: 30)
+ * @returns {Array} Array of sent email entries within the time range
+ */
+function getRecentSent(days = 30) {
+  const log = readSentLog();
+  const cutoff = new Date();
+  cutoff.setDate(cutoff.getDate() - days);
+
+  return log.filter((entry) => {
+    const sentAt = new Date(entry.sentAt);
+    return sentAt >= cutoff;
+  });
+}
+
+/**
+ * Gets the path to the log file (for display purposes)
+ * @returns {string} The log file path
+ */
+function getSentLogPath() {
+  return LOG_FILE;
+}
+
+module.exports = {
+  logSentEmail,
+  getRecentSent,
+  getSentLogPath,
+  readSentLog,
+};

package/tests/gmail-monitor-patterns.test.js

@@ -0,0 +1,232 @@
+import { describe, it, expect } from 'vitest';
+
+// Import the actual exported helper functions for testing
+// These are pure functions that don't require mocking
+const { extractBody, decodeBase64Url, composeMessage } = require('../src/gmail-monitor');
+
+describe('Gmail Monitor New Features', () => {
+
+  describe('decodeBase64Url', () => {
+    it('should decode base64url encoded string', () => {
+      const encoded = Buffer.from('Hello world').toString('base64url');
+      expect(decodeBase64Url(encoded)).toBe('Hello world');
+    });
+
+    it('should return empty string for empty input', () => {
+      expect(decodeBase64Url('')).toBe('');
+      expect(decodeBase64Url(null)).toBe('');
+      expect(decodeBase64Url(undefined)).toBe('');
+    });
+
+    it('should handle unicode content', () => {
+      const encoded = Buffer.from('Hello 世界 🌍').toString('base64url');
+      expect(decodeBase64Url(encoded)).toBe('Hello 世界 🌍');
+    });
+  });
+
+  describe('extractBody', () => {
+    it('should extract body from simple text/plain payload', () => {
+      const payload = {
+        mimeType: 'text/plain',
+        body: {
+          data: Buffer.from('Hello world').toString('base64url')
+        }
+      };
+      const result = extractBody(payload);
+      expect(result.content).toBe('Hello world');
+      expect(result.type).toBe('text/plain');
+    });
+
+    it('should prefer text/plain in multipart/alternative', () => {
+      const payload = {
+        mimeType: 'multipart/alternative',
+        parts: [
+          {
+            mimeType: 'text/html',
+            body: { data: Buffer.from('<b>HTML</b>').toString('base64url') }
+          },
+          {
+            mimeType: 'text/plain',
+            body: { data: Buffer.from('Plain text').toString('base64url') }
+          }
+        ]
+      };
+      const result = extractBody(payload);
+      expect(result.content).toBe('Plain text');
+      expect(result.type).toBe('text/plain');
+    });
+
+    it('should fallback to text/html if no plain text', () => {
+      const payload = {
+        mimeType: 'multipart/alternative',
+        parts: [
+          {
+            mimeType: 'text/html',
+            body: { data: Buffer.from('<b>HTML only</b>').toString('base64url') }
+          }
+        ]
+      };
+      const result = extractBody(payload);
+      expect(result.content).toBe('<b>HTML only</b>');
+      expect(result.type).toBe('text/html');
+    });
+
+    it('should handle nested multipart (multipart/mixed with multipart/alternative)', () => {
+      const payload = {
+        mimeType: 'multipart/mixed',
+        parts: [
+          {
+            mimeType: 'multipart/alternative',
+            parts: [
+              {
+                mimeType: 'text/plain',
+                body: { data: Buffer.from('Nested plain').toString('base64url') }
+              }
+            ]
+          },
+          {
+            mimeType: 'application/pdf',
+            filename: 'attachment.pdf',
+            body: { attachmentId: 'xyz' }
+          }
+        ]
+      };
+      const result = extractBody(payload);
+      expect(result.content).toBe('Nested plain');
+      expect(result.type).toBe('text/plain');
+    });
+
+    it('should return empty content for payload with no body data', () => {
+      const payload = {
+        mimeType: 'text/plain'
+        // no body
+      };
+      const result = extractBody(payload);
+      expect(result.content).toBe('');
+      expect(result.type).toBe('text/plain');
+    });
+
+    it('should handle parts without body data', () => {
+      const payload = {
+        mimeType: 'multipart/mixed',
+        parts: [
+          {
+            mimeType: 'text/plain'
+            // no body data
+          }
+        ]
+      };
+      const result = extractBody(payload);
+      expect(result.content).toBe('');
+    });
+  });
+
+  describe('composeMessage', () => {
+    it('should compose a simple email message', () => {
+      const encoded = composeMessage({
+        to: 'test@example.com',
+        subject: 'Test Subject',
+        body: 'Hello Body'
+      });
+
+      const decoded = Buffer.from(encoded, 'base64url').toString('utf8');
+
+      expect(decoded).toContain('To: test@example.com');
+      expect(decoded).toContain('Subject: Test Subject');
+      expect(decoded).toContain('Content-Type: text/plain; charset="UTF-8"');
+      expect(decoded).toContain('MIME-Version: 1.0');
+      expect(decoded).toContain('Hello Body');
+    });
+
+    it('should include In-Reply-To and References headers for replies', () => {
+      const encoded = composeMessage({
+        to: 'sender@example.com',
+        subject: 'Re: Original Subject',
+        body: 'My reply',
+        inReplyTo: '<msg123@example.com>',
+        references: '<ref1@example.com> <msg123@example.com>'
+      });
+
+      const decoded = Buffer.from(encoded, 'base64url').toString('utf8');
+
+      expect(decoded).toContain('In-Reply-To: <msg123@example.com>');
+      expect(decoded).toContain('References: <ref1@example.com> <msg123@example.com>');
+    });
+
+    it('should not include reply headers when not provided', () => {
+      const encoded = composeMessage({
+        to: 'test@example.com',
+        subject: 'New Email',
+        body: 'Body'
+      });
+
+      const decoded = Buffer.from(encoded, 'base64url').toString('utf8');
+
+      expect(decoded).not.toContain('In-Reply-To:');
+      expect(decoded).not.toContain('References:');
+    });
+
+    it('should handle special characters in subject and body', () => {
+      const encoded = composeMessage({
+        to: 'test@example.com',
+        subject: 'Test: Special chars & symbols!',
+        body: 'Line 1\nLine 2\n\nParagraph with émojis 🎉'
+      });
+
+      const decoded = Buffer.from(encoded, 'base64url').toString('utf8');
+
+      expect(decoded).toContain('Subject: Test: Special chars & symbols!');
+      expect(decoded).toContain('émojis 🎉');
+    });
+  });
+
+  describe('Reply Subject Logic', () => {
+    // Test the Re: prefix logic used in replyToEmail
+    function buildReplySubject(originalSubject) {
+      return originalSubject.toLowerCase().startsWith('re:')
+        ? originalSubject
+        : `Re: ${originalSubject}`;
+    }
+
+    it('should add Re: prefix to new subject', () => {
+      expect(buildReplySubject('Hello')).toBe('Re: Hello');
+    });
+
+    it('should not double Re: prefix', () => {
+      expect(buildReplySubject('Re: Hello')).toBe('Re: Hello');
+      expect(buildReplySubject('RE: Hello')).toBe('RE: Hello');
+      expect(buildReplySubject('re: Hello')).toBe('re: Hello');
+    });
+
+    it('should handle edge cases', () => {
+      expect(buildReplySubject('')).toBe('Re: ');
+      expect(buildReplySubject('Re:')).toBe('Re:');
+      expect(buildReplySubject('Re: Re: Multiple')).toBe('Re: Re: Multiple');
+    });
+  });
+
+  describe('References Chain Logic', () => {
+    // Test the references building logic used in replyToEmail
+    function buildReferences(originalReferences, originalMessageId) {
+      return originalReferences
+        ? `${originalReferences} ${originalMessageId}`
+        : originalMessageId;
+    }
+
+    it('should use message ID when no existing references', () => {
+      expect(buildReferences('', '<msg1@example.com>')).toBe('<msg1@example.com>');
+      expect(buildReferences(null, '<msg1@example.com>')).toBe('<msg1@example.com>');
+    });
+
+    it('should append message ID to existing references', () => {
+      expect(buildReferences('<ref1@example.com>', '<msg1@example.com>'))
+        .toBe('<ref1@example.com> <msg1@example.com>');
+    });
+
+    it('should build long reference chains', () => {
+      const refs = '<ref1@ex.com> <ref2@ex.com>';
+      expect(buildReferences(refs, '<msg1@ex.com>'))
+        .toBe('<ref1@ex.com> <ref2@ex.com> <msg1@ex.com>');
+    });
+  });
+});