inboxd 1.0.12 → 1.1.0

package/tests/json-output.test.js

@@ -0,0 +1,189 @@
+import { describe, it, expect } from 'vitest';
+
+// Test JSON output structures for commands that gained --json support
+// Validates the output format for AI agent consumption
+
+describe('JSON Output Formats', () => {
+  describe('inbox accounts --json', () => {
+    it('should output account list structure', () => {
+      const jsonOutput = {
+        accounts: [
+          { name: 'personal', email: 'user@gmail.com' },
+          { name: 'work', email: 'user@company.com' },
+        ],
+      };
+
+      expect(jsonOutput).toHaveProperty('accounts');
+      expect(Array.isArray(jsonOutput.accounts)).toBe(true);
+      expect(jsonOutput.accounts[0]).toHaveProperty('name');
+      expect(jsonOutput.accounts[0]).toHaveProperty('email');
+    });
+
+    it('should handle empty accounts list', () => {
+      const jsonOutput = {
+        accounts: [],
+      };
+
+      expect(jsonOutput.accounts).toEqual([]);
+    });
+  });
+
+  describe('inbox deletion-log --json', () => {
+    it('should output deletion log structure', () => {
+      const jsonOutput = {
+        days: 30,
+        count: 15,
+        logPath: '/Users/test/.config/inboxd/deletion-log.json',
+        deletions: [
+          {
+            deletedAt: '2026-01-03T15:45:00.000Z',
+            account: 'personal',
+            id: '19b84376ff5f5ed2',
+            threadId: '19b84376ff5f5ed2',
+            from: 'sender@example.com',
+            subject: 'Test Subject',
+            snippet: 'Email preview...',
+          },
+        ],
+      };
+
+      expect(jsonOutput).toHaveProperty('days');
+      expect(jsonOutput).toHaveProperty('count');
+      expect(jsonOutput).toHaveProperty('logPath');
+      expect(jsonOutput).toHaveProperty('deletions');
+      expect(Array.isArray(jsonOutput.deletions)).toBe(true);
+    });
+
+    it('should include all deletion entry fields', () => {
+      const deletion = {
+        deletedAt: '2026-01-03T15:45:00.000Z',
+        account: 'personal',
+        id: '19b84376ff5f5ed2',
+        threadId: '19b84376ff5f5ed2',
+        from: 'sender@example.com',
+        subject: 'Test Subject',
+        snippet: 'Email preview...',
+      };
+
+      expect(deletion).toHaveProperty('deletedAt');
+      expect(deletion).toHaveProperty('account');
+      expect(deletion).toHaveProperty('id');
+      expect(deletion).toHaveProperty('threadId');
+      expect(deletion).toHaveProperty('from');
+      expect(deletion).toHaveProperty('subject');
+      expect(deletion).toHaveProperty('snippet');
+    });
+  });
+
+  describe('inbox delete --dry-run --json', () => {
+    it('should output preview structure', () => {
+      const jsonOutput = {
+        dryRun: true,
+        count: 5,
+        emails: [
+          {
+            id: 'msg1',
+            account: 'personal',
+            from: 'sender@example.com',
+            subject: 'Test Subject',
+            date: 'Fri, 03 Jan 2026 10:30:00 -0800',
+          },
+        ],
+      };
+
+      expect(jsonOutput).toHaveProperty('dryRun');
+      expect(jsonOutput.dryRun).toBe(true);
+      expect(jsonOutput).toHaveProperty('count');
+      expect(jsonOutput).toHaveProperty('emails');
+      expect(Array.isArray(jsonOutput.emails)).toBe(true);
+    });
+
+    it('should include email details for each item', () => {
+      const email = {
+        id: 'msg1',
+        account: 'personal',
+        from: 'sender@example.com',
+        subject: 'Test Subject',
+        date: 'Fri, 03 Jan 2026 10:30:00 -0800',
+      };
+
+      expect(email).toHaveProperty('id');
+      expect(email).toHaveProperty('account');
+      expect(email).toHaveProperty('from');
+      expect(email).toHaveProperty('subject');
+      expect(email).toHaveProperty('date');
+    });
+
+    it('should handle empty preview', () => {
+      const jsonOutput = {
+        dryRun: true,
+        count: 0,
+        emails: [],
+      };
+
+      expect(jsonOutput.count).toBe(0);
+      expect(jsonOutput.emails).toEqual([]);
+    });
+  });
+
+  describe('inbox restore --json', () => {
+    it('should output restore results structure', () => {
+      const jsonOutput = {
+        restored: 3,
+        failed: 1,
+        results: [
+          { id: 'msg1', account: 'personal', from: 'a@b.com', subject: 'Test', success: true },
+          { id: 'msg2', account: 'work', from: 'c@d.com', subject: 'Test 2', success: false },
+        ],
+      };
+
+      expect(jsonOutput).toHaveProperty('restored');
+      expect(jsonOutput).toHaveProperty('failed');
+      expect(jsonOutput).toHaveProperty('results');
+      expect(Array.isArray(jsonOutput.results)).toBe(true);
+    });
+
+    it('should include success status for each result', () => {
+      const result = {
+        id: 'msg1',
+        account: 'personal',
+        from: 'a@b.com',
+        subject: 'Test',
+        success: true,
+      };
+
+      expect(result).toHaveProperty('success');
+      expect(typeof result.success).toBe('boolean');
+    });
+
+    it('should output error structure on failure', () => {
+      const jsonOutput = {
+        error: 'Must specify either --ids or --last',
+      };
+
+      expect(jsonOutput).toHaveProperty('error');
+      expect(typeof jsonOutput.error).toBe('string');
+    });
+  });
+
+  describe('JSON formatting', () => {
+    it('should produce valid JSON', () => {
+      const data = {
+        accounts: [{ name: 'test', email: 'test@example.com' }],
+      };
+
+      const jsonString = JSON.stringify(data, null, 2);
+      const parsed = JSON.parse(jsonString);
+
+      expect(parsed).toEqual(data);
+    });
+
+    it('should use 2-space indentation', () => {
+      const data = { key: 'value' };
+      const jsonString = JSON.stringify(data, null, 2);
+
+      expect(jsonString).toContain('\n');
+      expect(jsonString).toContain('  '); // 2-space indent
+    });
+  });
+});

package/tests/stats.test.js

@@ -0,0 +1,218 @@
+import { describe, it, expect } from 'vitest';
+
+// Test the stats logic without importing real modules
+// This follows the pattern used in deletion-log.test.js
+
+describe('Stats Command', () => {
+  describe('extractDomain helper', () => {
+    // Mirrors the extractDomain function in deletion-log.js
+    function extractDomain(from) {
+      const match = from.match(/@([a-zA-Z0-9.-]+)/);
+      return match ? match[1].toLowerCase() : 'unknown';
+    }
+
+    it('should extract domain from email in angle brackets', () => {
+      expect(extractDomain('John Doe <john@example.com>')).toBe('example.com');
+    });
+
+    it('should extract domain from bare email', () => {
+      expect(extractDomain('john@example.com')).toBe('example.com');
+    });
+
+    it('should handle subdomain', () => {
+      expect(extractDomain('noreply@mail.linkedin.com')).toBe('mail.linkedin.com');
+    });
+
+    it('should return unknown for invalid format', () => {
+      expect(extractDomain('No Email Here')).toBe('unknown');
+      expect(extractDomain('')).toBe('unknown');
+    });
+
+    it('should lowercase the domain', () => {
+      expect(extractDomain('user@EXAMPLE.COM')).toBe('example.com');
+    });
+  });
+
+  describe('Deletion Stats', () => {
+    // Mirrors getStats() logic from deletion-log.js
+    function getStats(deletions) {
+      const byAccount = {};
+      deletions.forEach(d => {
+        const account = d.account || 'default';
+        byAccount[account] = (byAccount[account] || 0) + 1;
+      });
+
+      const bySender = {};
+      deletions.forEach(d => {
+        const match = (d.from || '').match(/@([a-zA-Z0-9.-]+)/);
+        const domain = match ? match[1].toLowerCase() : 'unknown';
+        bySender[domain] = (bySender[domain] || 0) + 1;
+      });
+
+      const topSenders = Object.entries(bySender)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10)
+        .map(([domain, count]) => ({ domain, count }));
+
+      return {
+        total: deletions.length,
+        byAccount,
+        topSenders,
+      };
+    }
+
+    it('should count total deletions', () => {
+      const deletions = [
+        { id: '1', account: 'personal', from: 'a@example.com' },
+        { id: '2', account: 'work', from: 'b@test.com' },
+        { id: '3', account: 'personal', from: 'c@example.com' },
+      ];
+      const stats = getStats(deletions);
+      expect(stats.total).toBe(3);
+    });
+
+    it('should group by account', () => {
+      const deletions = [
+        { id: '1', account: 'personal', from: 'a@example.com' },
+        { id: '2', account: 'work', from: 'b@test.com' },
+        { id: '3', account: 'personal', from: 'c@example.com' },
+      ];
+      const stats = getStats(deletions);
+      expect(stats.byAccount).toEqual({ personal: 2, work: 1 });
+    });
+
+    it('should use default for missing account', () => {
+      const deletions = [
+        { id: '1', from: 'a@example.com' },
+      ];
+      const stats = getStats(deletions);
+      expect(stats.byAccount).toEqual({ default: 1 });
+    });
+
+    it('should rank top senders by count', () => {
+      const deletions = [
+        { id: '1', from: 'a@linkedin.com', account: 'test' },
+        { id: '2', from: 'b@linkedin.com', account: 'test' },
+        { id: '3', from: 'c@linkedin.com', account: 'test' },
+        { id: '4', from: 'd@amazon.com', account: 'test' },
+        { id: '5', from: 'e@amazon.com', account: 'test' },
+        { id: '6', from: 'f@github.com', account: 'test' },
+      ];
+      const stats = getStats(deletions);
+      expect(stats.topSenders[0]).toEqual({ domain: 'linkedin.com', count: 3 });
+      expect(stats.topSenders[1]).toEqual({ domain: 'amazon.com', count: 2 });
+      expect(stats.topSenders[2]).toEqual({ domain: 'github.com', count: 1 });
+    });
+
+    it('should limit top senders to 10', () => {
+      const deletions = [];
+      for (let i = 0; i < 15; i++) {
+        deletions.push({ id: `${i}`, from: `user@domain${i}.com`, account: 'test' });
+      }
+      const stats = getStats(deletions);
+      expect(stats.topSenders.length).toBe(10);
+    });
+
+    it('should handle empty deletions', () => {
+      const stats = getStats([]);
+      expect(stats.total).toBe(0);
+      expect(stats.byAccount).toEqual({});
+      expect(stats.topSenders).toEqual([]);
+    });
+  });
+
+  describe('Sent Stats', () => {
+    // Mirrors getSentStats() logic from sent-log.js
+    function getSentStats(sent) {
+      let replies = 0;
+      let newEmails = 0;
+      sent.forEach(s => {
+        if (s.replyToId) {
+          replies++;
+        } else {
+          newEmails++;
+        }
+      });
+
+      const byAccount = {};
+      sent.forEach(s => {
+        const account = s.account || 'default';
+        byAccount[account] = (byAccount[account] || 0) + 1;
+      });
+
+      return {
+        total: sent.length,
+        replies,
+        newEmails,
+        byAccount,
+      };
+    }
+
+    it('should count total sent emails', () => {
+      const sent = [
+        { id: '1', account: 'personal' },
+        { id: '2', account: 'work' },
+      ];
+      const stats = getSentStats(sent);
+      expect(stats.total).toBe(2);
+    });
+
+    it('should distinguish replies from new emails', () => {
+      const sent = [
+        { id: '1', account: 'test', replyToId: 'orig1' },
+        { id: '2', account: 'test', replyToId: 'orig2' },
+        { id: '3', account: 'test', replyToId: null },
+        { id: '4', account: 'test' },
+      ];
+      const stats = getSentStats(sent);
+      expect(stats.replies).toBe(2);
+      expect(stats.newEmails).toBe(2);
+    });
+
+    it('should group by account', () => {
+      const sent = [
+        { id: '1', account: 'personal' },
+        { id: '2', account: 'work' },
+        { id: '3', account: 'personal' },
+      ];
+      const stats = getSentStats(sent);
+      expect(stats.byAccount).toEqual({ personal: 2, work: 1 });
+    });
+
+    it('should handle empty sent list', () => {
+      const stats = getSentStats([]);
+      expect(stats.total).toBe(0);
+      expect(stats.replies).toBe(0);
+      expect(stats.newEmails).toBe(0);
+      expect(stats.byAccount).toEqual({});
+    });
+  });
+
+  describe('Stats JSON output structure', () => {
+    it('should have correct structure for JSON output', () => {
+      const jsonOutput = {
+        period: 30,
+        deleted: {
+          total: 10,
+          byAccount: { personal: 5, work: 5 },
+          topSenders: [{ domain: 'example.com', count: 3 }],
+        },
+        sent: {
+          total: 3,
+          replies: 2,
+          newEmails: 1,
+          byAccount: { personal: 3 },
+        },
+      };
+
+      expect(jsonOutput).toHaveProperty('period');
+      expect(jsonOutput).toHaveProperty('deleted');
+      expect(jsonOutput).toHaveProperty('sent');
+      expect(jsonOutput.deleted).toHaveProperty('total');
+      expect(jsonOutput.deleted).toHaveProperty('byAccount');
+      expect(jsonOutput.deleted).toHaveProperty('topSenders');
+      expect(jsonOutput.sent).toHaveProperty('replies');
+      expect(jsonOutput.sent).toHaveProperty('newEmails');
+    });
+  });
+});

package/tests/unarchive.test.js

@@ -0,0 +1,228 @@
+import { describe, it, expect, vi } from 'vitest';
+
+// Test unarchive command logic
+// Tests the gmail-monitor unarchiveEmails and CLI command logic
+
+describe('Unarchive Command', () => {
+  describe('unarchiveEmails API logic', () => {
+    // Simulates the unarchiveEmails function in gmail-monitor.js
+    async function unarchiveEmails(mockGmail, messageIds) {
+      const results = [];
+
+      for (const id of messageIds) {
+        try {
+          await mockGmail.users.messages.modify({
+            userId: 'me',
+            id: id,
+            requestBody: {
+              addLabelIds: ['INBOX'],
+            },
+          });
+          results.push({ id, success: true });
+        } catch (err) {
+          results.push({ id, success: false, error: err.message });
+        }
+      }
+
+      return results;
+    }
+
+    it('should add INBOX label to unarchive emails', async () => {
+      const modifyCalls = [];
+      const mockGmail = {
+        users: {
+          messages: {
+            modify: vi.fn().mockImplementation((params) => {
+              modifyCalls.push(params);
+              return Promise.resolve({ data: { id: params.id } });
+            }),
+          },
+        },
+      };
+
+      await unarchiveEmails(mockGmail, ['msg1', 'msg2']);
+
+      expect(modifyCalls).toHaveLength(2);
+      expect(modifyCalls[0].requestBody.addLabelIds).toContain('INBOX');
+      expect(modifyCalls[1].requestBody.addLabelIds).toContain('INBOX');
+    });
+
+    it('should return success for each email', async () => {
+      const mockGmail = {
+        users: {
+          messages: {
+            modify: vi.fn().mockResolvedValue({ data: {} }),
+          },
+        },
+      };
+
+      const results = await unarchiveEmails(mockGmail, ['msg1', 'msg2']);
+
+      expect(results).toHaveLength(2);
+      expect(results[0]).toEqual({ id: 'msg1', success: true });
+      expect(results[1]).toEqual({ id: 'msg2', success: true });
+    });
+
+    it('should handle API errors gracefully', async () => {
+      const mockGmail = {
+        users: {
+          messages: {
+            modify: vi.fn()
+              .mockResolvedValueOnce({ data: {} })
+              .mockRejectedValueOnce(new Error('Not found'))
+              .mockResolvedValueOnce({ data: {} }),
+          },
+        },
+      };
+
+      const results = await unarchiveEmails(mockGmail, ['msg1', 'msg2', 'msg3']);
+
+      expect(results).toHaveLength(3);
+      expect(results[0].success).toBe(true);
+      expect(results[1].success).toBe(false);
+      expect(results[1].error).toBe('Not found');
+      expect(results[2].success).toBe(true);
+    });
+
+    it('should handle empty message list', async () => {
+      const mockGmail = {
+        users: {
+          messages: {
+            modify: vi.fn(),
+          },
+        },
+      };
+
+      const results = await unarchiveEmails(mockGmail, []);
+
+      expect(results).toHaveLength(0);
+      expect(mockGmail.users.messages.modify).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Command option parsing', () => {
+    it('should parse --ids option into array', () => {
+      const idsString = 'id1,id2,id3';
+      const ids = idsString.split(',').map(id => id.trim()).filter(Boolean);
+
+      expect(ids).toEqual(['id1', 'id2', 'id3']);
+    });
+
+    it('should handle whitespace in --ids', () => {
+      const idsString = 'id1, id2 , id3';
+      const ids = idsString.split(',').map(id => id.trim()).filter(Boolean);
+
+      expect(ids).toEqual(['id1', 'id2', 'id3']);
+    });
+
+    it('should filter empty strings from --ids', () => {
+      const idsString = 'id1,,id2,';
+      const ids = idsString.split(',').map(id => id.trim()).filter(Boolean);
+
+      expect(ids).toEqual(['id1', 'id2']);
+    });
+
+    it('should parse --last option as integer', () => {
+      const lastValue = '5';
+      const count = parseInt(lastValue, 10);
+
+      expect(count).toBe(5);
+      expect(typeof count).toBe('number');
+    });
+  });
+
+  describe('Archive log lookup', () => {
+    it('should find email in archive log by id', () => {
+      const archiveLog = [
+        { id: 'msg1', account: 'personal', from: 'a@b.com', subject: 'Test 1' },
+        { id: 'msg2', account: 'work', from: 'c@d.com', subject: 'Test 2' },
+        { id: 'msg3', account: 'personal', from: 'e@f.com', subject: 'Test 3' },
+      ];
+
+      const idsToFind = ['msg1', 'msg3'];
+      const found = idsToFind
+        .map(id => archiveLog.find(e => e.id === id))
+        .filter(Boolean);
+
+      expect(found).toHaveLength(2);
+      expect(found[0].id).toBe('msg1');
+      expect(found[1].id).toBe('msg3');
+    });
+
+    it('should return undefined for missing ids', () => {
+      const archiveLog = [
+        { id: 'msg1', account: 'personal' },
+      ];
+
+      const entry = archiveLog.find(e => e.id === 'nonexistent');
+      expect(entry).toBeUndefined();
+    });
+  });
+
+  describe('Grouping by account', () => {
+    it('should group emails by account for batch operations', () => {
+      const emailsToUnarchive = [
+        { id: 'msg1', account: 'personal' },
+        { id: 'msg2', account: 'work' },
+        { id: 'msg3', account: 'personal' },
+        { id: 'msg4', account: 'work' },
+      ];
+
+      const byAccount = {};
+      for (const email of emailsToUnarchive) {
+        if (!byAccount[email.account]) {
+          byAccount[email.account] = [];
+        }
+        byAccount[email.account].push(email);
+      }
+
+      expect(Object.keys(byAccount)).toEqual(['personal', 'work']);
+      expect(byAccount.personal).toHaveLength(2);
+      expect(byAccount.work).toHaveLength(2);
+    });
+  });
+
+  describe('JSON output structure', () => {
+    it('should have correct structure for success', () => {
+      const jsonOutput = {
+        unarchived: 3,
+        failed: 1,
+        results: [
+          { id: 'msg1', account: 'personal', from: 'a@b.com', subject: 'Test', success: true },
+          { id: 'msg2', account: 'work', from: 'c@d.com', subject: 'Test 2', success: false },
+        ],
+      };
+
+      expect(jsonOutput).toHaveProperty('unarchived');
+      expect(jsonOutput).toHaveProperty('failed');
+      expect(jsonOutput).toHaveProperty('results');
+      expect(Array.isArray(jsonOutput.results)).toBe(true);
+      expect(jsonOutput.results[0]).toHaveProperty('success');
+    });
+
+    it('should have correct structure for error', () => {
+      const jsonOutput = {
+        error: 'Must specify either --ids or --last',
+      };
+
+      expect(jsonOutput).toHaveProperty('error');
+    });
+  });
+
+  describe('Result counting', () => {
+    it('should count successful and failed operations', () => {
+      const results = [
+        { id: 'msg1', success: true },
+        { id: 'msg2', success: true },
+        { id: 'msg3', success: false },
+        { id: 'msg4', success: true },
+      ];
+
+      const successfulIds = results.filter(r => r.success).map(r => r.id);
+      const failedCount = results.filter(r => !r.success).length;
+
+      expect(successfulIds).toEqual(['msg1', 'msg2', 'msg4']);
+      expect(failedCount).toBe(1);
+    });
+  });
+});