inboxd 1.0.11 → 1.0.12

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

package/tests/sent-log.test.js

@@ -0,0 +1,142 @@
+import { describe, it, expect } from 'vitest';
+import path from 'path';
+import os from 'os';
+
+// Test the logic patterns used by sent-log
+// Similar structure to deletion-log.test.js
+
+describe('Sent Log', () => {
+  const LOG_DIR = path.join(os.homedir(), '.config', 'inboxd');
+  const LOG_FILE = path.join(LOG_DIR, 'sent-log.json');
+
+  describe('Log entry structure', () => {
+    it('should have required fields for sent email tracking', () => {
+      const logEntry = {
+        sentAt: '2026-01-03T15:45:00.000Z',
+        account: 'dparedesi@uni.pe',
+        id: '19b84376ff5f5ed2',
+        threadId: '19b84376ff5f5ed2',
+        to: 'recipient@example.com',
+        subject: 'Test Subject',
+        bodyPreview: 'First 200 chars of body...',
+        replyToId: null,
+      };
+
+      expect(logEntry).toHaveProperty('sentAt');
+      expect(logEntry).toHaveProperty('account');
+      expect(logEntry).toHaveProperty('id');
+      expect(logEntry).toHaveProperty('threadId');
+      expect(logEntry).toHaveProperty('to');
+      expect(logEntry).toHaveProperty('subject');
+      expect(logEntry).toHaveProperty('bodyPreview');
+      expect(logEntry).toHaveProperty('replyToId');
+    });
+
+    it('should track reply-to for replies', () => {
+      const replyEntry = {
+        sentAt: new Date().toISOString(),
+        account: 'test',
+        id: 'new-id',
+        threadId: 'thread-id',
+        to: 'sender@example.com',
+        subject: 'Re: Original Subject',
+        bodyPreview: 'My reply...',
+        replyToId: 'original-message-id',
+      };
+
+      expect(replyEntry.replyToId).toBe('original-message-id');
+    });
+
+    it('should have null replyToId for new messages', () => {
+      const newEmailEntry = {
+        sentAt: new Date().toISOString(),
+        account: 'test',
+        id: 'new-id',
+        threadId: 'thread-id',
+        to: 'recipient@example.com',
+        subject: 'New Subject',
+        bodyPreview: 'Body...',
+        replyToId: null,
+      };
+
+      expect(newEmailEntry.replyToId).toBeNull();
+    });
+  });
+
+  describe('Body preview logic', () => {
+    it('should truncate body to 200 chars', () => {
+      const longBody = 'A'.repeat(500);
+      const preview = longBody.substring(0, 200);
+
+      expect(preview).toHaveLength(200);
+    });
+
+    it('should not truncate short body', () => {
+      const shortBody = 'Short message';
+      const preview = shortBody.substring(0, 200);
+
+      expect(preview).toBe('Short message');
+    });
+  });
+
+  describe('Log filtering', () => {
+    it('should filter entries by date range', () => {
+      const now = new Date();
+      const tenDaysAgo = new Date(now);
+      tenDaysAgo.setDate(tenDaysAgo.getDate() - 10);
+      const fortyDaysAgo = new Date(now);
+      fortyDaysAgo.setDate(fortyDaysAgo.getDate() - 40);
+
+      const entries = [
+        { sentAt: now.toISOString(), id: 'recent' },
+        { sentAt: tenDaysAgo.toISOString(), id: 'ten-days' },
+        { sentAt: fortyDaysAgo.toISOString(), id: 'forty-days' },
+      ];
+
+      const cutoff = new Date();
+      cutoff.setDate(cutoff.getDate() - 30);
+
+      const recentEntries = entries.filter((e) => new Date(e.sentAt) >= cutoff);
+
+      expect(recentEntries).toHaveLength(2);
+      expect(recentEntries.map(e => e.id)).toContain('recent');
+      expect(recentEntries.map(e => e.id)).toContain('ten-days');
+      expect(recentEntries.map(e => e.id)).not.toContain('forty-days');
+    });
+  });
+
+  describe('Log path', () => {
+    it('should use correct log directory path', () => {
+      expect(LOG_DIR).toContain('.config');
+      expect(LOG_DIR).toContain('inboxd');
+    });
+
+    it('should use correct log file name', () => {
+      expect(LOG_FILE).toContain('sent-log.json');
+    });
+  });
+
+  describe('Empty log handling', () => {
+    it('should return empty array for empty log', () => {
+      const emptyLog = [];
+      expect(emptyLog).toHaveLength(0);
+      expect(Array.isArray(emptyLog)).toBe(true);
+    });
+
+    it('should handle missing log file gracefully', () => {
+      // Simulate the readSentLog behavior when file doesn't exist
+      const readLogSafe = (fileExists, fileContent) => {
+        if (!fileExists) return [];
+        try {
+          return JSON.parse(fileContent);
+        } catch {
+          return [];
+        }
+      };
+
+      expect(readLogSafe(false, '')).toEqual([]);
+      expect(readLogSafe(true, 'invalid json')).toEqual([]);
+      expect(readLogSafe(true, '[]')).toEqual([]);
+    });
+  });
+});