inboxd 1.0.10 → 1.0.12

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>');
+    });
+  });
+});

package/tests/link-extraction.test.js

@@ -0,0 +1,249 @@
+import { describe, it, expect } from 'vitest';
+
+const { extractLinks, isValidUrl, decodeHtmlEntities, extractBody } = require('../src/gmail-monitor');
+
+describe('Link Extraction', () => {
+
+  describe('isValidUrl', () => {
+    it('should accept http URLs', () => {
+      expect(isValidUrl('http://example.com')).toBe(true);
+    });
+
+    it('should accept https URLs', () => {
+      expect(isValidUrl('https://example.com')).toBe(true);
+      expect(isValidUrl('https://example.com/path?query=1')).toBe(true);
+    });
+
+    it('should reject javascript: URLs', () => {
+      expect(isValidUrl('javascript:void(0)')).toBe(false);
+      expect(isValidUrl('javascript:alert("hi")')).toBe(false);
+    });
+
+    it('should reject data: URLs', () => {
+      expect(isValidUrl('data:text/html,<h1>Hello</h1>')).toBe(false);
+    });
+
+    it('should reject mailto: URLs', () => {
+      expect(isValidUrl('mailto:test@example.com')).toBe(false);
+    });
+
+    it('should reject tel: URLs', () => {
+      expect(isValidUrl('tel:+1234567890')).toBe(false);
+    });
+
+    it('should reject file: URLs', () => {
+      expect(isValidUrl('file:///etc/passwd')).toBe(false);
+    });
+
+    it('should handle null/undefined/empty', () => {
+      expect(isValidUrl(null)).toBe(false);
+      expect(isValidUrl(undefined)).toBe(false);
+      expect(isValidUrl('')).toBe(false);
+    });
+
+    it('should be case insensitive', () => {
+      expect(isValidUrl('HTTP://EXAMPLE.COM')).toBe(true);
+      expect(isValidUrl('HTTPS://EXAMPLE.COM')).toBe(true);
+      expect(isValidUrl('JAVASCRIPT:void(0)')).toBe(false);
+    });
+  });
+
+  describe('decodeHtmlEntities', () => {
+    it('should decode &amp;', () => {
+      expect(decodeHtmlEntities('a&amp;b')).toBe('a&b');
+    });
+
+    it('should decode &lt; and &gt;', () => {
+      expect(decodeHtmlEntities('&lt;tag&gt;')).toBe('<tag>');
+    });
+
+    it('should decode &quot;', () => {
+      expect(decodeHtmlEntities('&quot;hello&quot;')).toBe('"hello"');
+    });
+
+    it('should decode &#39;', () => {
+      expect(decodeHtmlEntities('it&#39;s')).toBe("it's");
+    });
+
+    it('should handle empty/null', () => {
+      expect(decodeHtmlEntities('')).toBe('');
+      expect(decodeHtmlEntities(null)).toBe('');
+      expect(decodeHtmlEntities(undefined)).toBe('');
+    });
+
+    it('should decode multiple entities', () => {
+      expect(decodeHtmlEntities('a&amp;b&lt;c')).toBe('a&b<c');
+    });
+  });
+
+  describe('extractLinks from HTML', () => {
+    it('should extract href from anchor tags', () => {
+      const html = '<a href="https://example.com">Click here</a>';
+      const links = extractLinks(html, 'text/html');
+      expect(links).toHaveLength(1);
+      expect(links[0].url).toBe('https://example.com');
+      expect(links[0].text).toBe('Click here');
+    });
+
+    it('should extract multiple links', () => {
+      const html = `
+        <a href="https://example.com/1">Link 1</a>
+        <a href="https://example.com/2">Link 2</a>
+      `;
+      const links = extractLinks(html, 'text/html');
+      expect(links).toHaveLength(2);
+      expect(links[0].url).toBe('https://example.com/1');
+      expect(links[1].url).toBe('https://example.com/2');
+    });
+
+    it('should deduplicate URLs', () => {
+      const html = `
+        <a href="https://example.com">First</a>
+        <a href="https://example.com">Second</a>
+      `;
+      const links = extractLinks(html, 'text/html');
+      expect(links).toHaveLength(1);
+      expect(links[0].text).toBe('First'); // First occurrence wins
+    });
+
+    it('should filter out javascript: URLs', () => {
+      const html = `
+        <a href="javascript:alert('hi')">JS</a>
+        <a href="https://real.com">Real</a>
+      `;
+      const links = extractLinks(html, 'text/html');
+      expect(links).toHaveLength(1);
+      expect(links[0].url).toBe('https://real.com');
+    });
+
+    it('should filter out mailto: URLs', () => {
+      const html = `
+        <a href="mailto:test@example.com">Email</a>
+        <a href="https://real.com">Real</a>
+      `;
+      const links = extractLinks(html, 'text/html');
+      expect(links).toHaveLength(1);
+      expect(links[0].url).toBe('https://real.com');
+    });
+
+    it('should decode HTML entities in URLs', () => {
+      const html = '<a href="https://example.com?a=1&amp;b=2">Link</a>';
+      const links = extractLinks(html, 'text/html');
+      expect(links).toHaveLength(1);
+      expect(links[0].url).toBe('https://example.com?a=1&b=2');
+    });
+
+    it('should handle links with extra attributes', () => {
+      const html = '<a class="btn" href="https://example.com" target="_blank">Link</a>';
+      const links = extractLinks(html, 'text/html');
+      expect(links).toHaveLength(1);
+      expect(links[0].url).toBe('https://example.com');
+    });
+
+    it('should also extract plain URLs not in anchor tags', () => {
+      const html = '<p>Visit https://plain-url.com for more info</p>';
+      const links = extractLinks(html, 'text/html');
+      expect(links).toHaveLength(1);
+      expect(links[0].url).toBe('https://plain-url.com');
+      expect(links[0].text).toBe(null);
+    });
+  });
+
+  describe('extractLinks from plain text', () => {
+    it('should extract URLs from plain text', () => {
+      const text = 'Check out https://example.com for more info';
+      const links = extractLinks(text, 'text/plain');
+      expect(links).toHaveLength(1);
+      expect(links[0].url).toBe('https://example.com');
+      expect(links[0].text).toBe(null);
+    });
+
+    it('should handle URLs with trailing punctuation', () => {
+      const text = 'Visit https://example.com, or https://other.com.';
+      const links = extractLinks(text, 'text/plain');
+      expect(links).toHaveLength(2);
+      expect(links[0].url).toBe('https://example.com');
+      expect(links[1].url).toBe('https://other.com');
+    });
+
+    it('should handle URLs with query strings', () => {
+      const text = 'Link: https://example.com/path?foo=bar&baz=qux';
+      const links = extractLinks(text, 'text/plain');
+      expect(links).toHaveLength(1);
+      expect(links[0].url).toBe('https://example.com/path?foo=bar&baz=qux');
+    });
+
+    it('should handle multiple URLs on same line', () => {
+      const text = 'See https://one.com and https://two.com';
+      const links = extractLinks(text, 'text/plain');
+      expect(links).toHaveLength(2);
+    });
+
+    it('should return empty array for no links', () => {
+      const text = 'No links here, just plain text';
+      const links = extractLinks(text, 'text/plain');
+      expect(links).toHaveLength(0);
+    });
+
+    it('should handle empty body', () => {
+      expect(extractLinks('', 'text/plain')).toHaveLength(0);
+      expect(extractLinks(null, 'text/plain')).toHaveLength(0);
+      expect(extractLinks(undefined, 'text/plain')).toHaveLength(0);
+    });
+  });
+
+  describe('extractBody with preferHtml option', () => {
+    it('should prefer text/plain by default', () => {
+      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 prefer text/html when preferHtml is true', () => {
+      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, { preferHtml: true });
+      expect(result.content).toBe('<b>HTML</b>');
+      expect(result.type).toBe('text/html');
+    });
+
+    it('should fallback to text/plain if no HTML available', () => {
+      const payload = {
+        mimeType: 'multipart/alternative',
+        parts: [
+          {
+            mimeType: 'text/plain',
+            body: { data: Buffer.from('Plain text').toString('base64url') }
+          }
+        ]
+      };
+      const result = extractBody(payload, { preferHtml: true });
+      expect(result.content).toBe('Plain text');
+      expect(result.type).toBe('text/plain');
+    });
+  });
+});

package/tests/older-than.test.js

@@ -0,0 +1,127 @@
+import { describe, it, expect } from 'vitest';
+
+// Test the older-than parsing logic used in inbox analyze command
+// We test the logic patterns directly since the function is not exported
+
+describe('Older Than Duration Parsing', () => {
+  /**
+   * Parsing function matching the implementation in cli.js
+   * Gmail only supports days (d) for older_than, so we convert weeks/months to days
+   */
+  function parseOlderThanDuration(duration) {
+    const match = duration.match(/^(\d+)([dwm])$/i);
+    if (!match) {
+      return null;
+    }
+
+    const value = parseInt(match[1], 10);
+    const unit = match[2].toLowerCase();
+
+    switch (unit) {
+      case 'd': // days
+        return `${value}d`;
+      case 'w': // weeks -> days
+        return `${value * 7}d`;
+      case 'm': // months (approximate as 30 days)
+        return `${value * 30}d`;
+      default:
+        return null;
+    }
+  }
+
+  describe('Days parsing', () => {
+    it('should parse days correctly', () => {
+      expect(parseOlderThanDuration('30d')).toBe('30d');
+      expect(parseOlderThanDuration('7d')).toBe('7d');
+      expect(parseOlderThanDuration('1d')).toBe('1d');
+      expect(parseOlderThanDuration('90d')).toBe('90d');
+    });
+  });
+
+  describe('Weeks conversion', () => {
+    it('should convert weeks to days', () => {
+      expect(parseOlderThanDuration('2w')).toBe('14d');
+      expect(parseOlderThanDuration('1w')).toBe('7d');
+      expect(parseOlderThanDuration('4w')).toBe('28d');
+    });
+  });
+
+  describe('Months conversion', () => {
+    it('should convert months to days (approx 30)', () => {
+      expect(parseOlderThanDuration('1m')).toBe('30d');
+      expect(parseOlderThanDuration('3m')).toBe('90d');
+      expect(parseOlderThanDuration('6m')).toBe('180d');
+    });
+  });
+
+  describe('Case insensitivity', () => {
+    it('should handle uppercase units', () => {
+      expect(parseOlderThanDuration('30D')).toBe('30d');
+      expect(parseOlderThanDuration('2W')).toBe('14d');
+      expect(parseOlderThanDuration('1M')).toBe('30d');
+    });
+  });
+
+  describe('Invalid formats', () => {
+    it('should return null for number without unit', () => {
+      expect(parseOlderThanDuration('30')).toBe(null);
+    });
+
+    it('should return null for unit without number', () => {
+      expect(parseOlderThanDuration('d')).toBe(null);
+      expect(parseOlderThanDuration('days')).toBe(null);
+    });
+
+    it('should return null for unsupported units', () => {
+      expect(parseOlderThanDuration('30h')).toBe(null); // hours not supported
+      expect(parseOlderThanDuration('30s')).toBe(null); // seconds not supported
+      expect(parseOlderThanDuration('30y')).toBe(null); // years not supported
+    });
+
+    it('should return null for empty/invalid strings', () => {
+      expect(parseOlderThanDuration('')).toBe(null);
+      expect(parseOlderThanDuration('abc')).toBe(null);
+      expect(parseOlderThanDuration('30 d')).toBe(null); // space not allowed
+    });
+  });
+});
+
+describe('Gmail Query Building for Older Than', () => {
+  /**
+   * Helper to simulate query building logic from cli.js analyze command
+   */
+  function buildQuery(includeRead, olderThanDays) {
+    const baseQuery = includeRead ? '' : 'is:unread';
+    if (!olderThanDays) {
+      return baseQuery;
+    }
+    const olderThanQuery = `older_than:${olderThanDays}`;
+    return baseQuery ? `${baseQuery} ${olderThanQuery}` : olderThanQuery;
+  }
+
+  it('should build correct query for unread + older_than', () => {
+    const query = buildQuery(false, '30d');
+    expect(query).toBe('is:unread older_than:30d');
+  });
+
+  it('should build correct query for all + older_than', () => {
+    const query = buildQuery(true, '30d');
+    expect(query).toBe('older_than:30d');
+  });
+
+  it('should build correct query for unread only (no older_than)', () => {
+    const query = buildQuery(false, null);
+    expect(query).toBe('is:unread');
+  });
+
+  it('should build correct query for all (no older_than)', () => {
+    const query = buildQuery(true, null);
+    expect(query).toBe('');
+  });
+
+  it('should work with week/month converted to days', () => {
+    // 2 weeks = 14 days
+    const query = buildQuery(false, '14d');
+    expect(query).toBe('is:unread older_than:14d');
+  });
+});